semantic_logger 4.18.0 → 5.1.0

data/docs/upgrading.md

@@ -0,0 +1,409 @@
+---
+layout: default
+---
+
+## Upgrading
+{:.no_toc}
+
+**Contents**
+
+* TOC
+{:toc}
+
+### Upgrading to Semantic Logger v5.1
+
+v5.1 deprecates several legacy appenders and one appender option. They all still work in v5.1, but
+each now emits a Ruby deprecation warning and will be **removed in v6**. The warnings use
+`category: :deprecated`, so they are silent by default and appear when deprecation warnings are
+enabled (for example `ruby -W:deprecated`, or Rails development mode). Switch away now to be ready
+for v6.
+
+#### Replace the `:sentry` appender with `:sentry_ruby`
+
+The `:sentry` appender depends on the end-of-life `sentry-raven` gem. Use the `:sentry_ruby`
+appender, backed by the maintained `sentry-ruby` gem.
+
+In your `Gemfile`:
+
+~~~ruby
+# Remove:
+gem "sentry-raven"
+# Add:
+gem "sentry-ruby"
+~~~
+
+When adding the appender:
+
+~~~ruby
+# Before:
+SemanticLogger.add_appender(appender: :sentry)
+
+# After:
+SemanticLogger.add_appender(appender: :sentry_ruby)
+~~~
+
+#### Replace the `:new_relic` appender with `:new_relic_logs`
+
+The `:new_relic` appender reports `:error` and `:fatal` entries to New Relic as **error events** via
+`newrelic_rpm`. It is superseded by `:new_relic_logs`, which forwards log entries to New Relic Logs:
+
+~~~ruby
+# Before:
+SemanticLogger.add_appender(appender: :new_relic)
+
+# After:
+SemanticLogger.add_appender(appender: :new_relic_logs)
+~~~
+
+Note that the behaviour differs. `:new_relic` created New Relic *error events* (and defaulted to the
+`:error` level), whereas `:new_relic_logs` forwards *log messages* to New Relic's log ingestion. Set
+`level:` to match what you want forwarded, and update any New Relic dashboards or alerts that relied
+on the old error events. Both appenders require the `newrelic_rpm` gem.
+
+#### Remove the `type:` option from the Elasticsearch and OpenSearch appenders
+
+Document `_type` has been unused since Elasticsearch 7, so the `type:` option (on `:elasticsearch`,
+`:elasticsearch_http`, and `:opensearch`) is now ignored on all server versions: the bulk appenders
+no longer send a `_type`, and the `:elasticsearch_http` appender posts to the typeless `_doc`
+endpoint. Passing `type:` logs a deprecation warning. Remove it:
+
+~~~ruby
+# Before:
+SemanticLogger.add_appender(appender: :elasticsearch, url: "http://localhost:9200", type: "log")
+
+# After:
+SemanticLogger.add_appender(appender: :elasticsearch, url: "http://localhost:9200")
+~~~
+
+### Upgrading to Semantic Logger v5.0
+
+#### Minimum Ruby version is now 3.2
+
+Semantic Logger v5 requires Ruby 3.2 or later. Earlier Ruby versions are end-of-life and are no
+longer supported or tested.
+
+If you are on an older Ruby, upgrade Ruby before upgrading Semantic Logger, or stay on the v4.x
+series.
+
+#### `SemanticLogger::Appender::AsyncBatch` has been removed
+
+The internal asynchronous proxy classes have been consolidated. Batch processing now runs through
+the same `SemanticLogger::Appender::Async` proxy (backed by an internal `QueueProcessor`), so the
+separate `SemanticLogger::Appender::AsyncBatch` class no longer exists.
+
+This only affects code that referenced the class directly, which is uncommon since appenders are
+added through `SemanticLogger.add_appender`. The `batch:`, `batch_size:`, and `batch_seconds:`
+options are unchanged:
+
+~~~ruby
+SemanticLogger.add_appender(appender: :http, url: "https://example.com/log", batch: true)
+~~~
+
+What changed:
+
+- `SemanticLogger.add_appender(..., batch: true)` now returns a `SemanticLogger::Appender::Async`
+  (with `#batch?` returning `true`) instead of a `SemanticLogger::Appender::AsyncBatch`.
+- Referencing the constant `SemanticLogger::Appender::AsyncBatch` now raises `NameError`.
+
+If you have a custom appender or test asserting on the proxy class, change
+`instance_of?`/`is_a?(SemanticLogger::Appender::AsyncBatch)` checks to
+`SemanticLogger::Appender::Async` and, if needed, check `appender.batch?`.
+
+#### Appenders are reopened automatically after fork
+
+Previously, applications that fork (Puma, Unicorn, Spring, Resque, `Process.daemon`, etc.) had to
+call `SemanticLogger.reopen` themselves in an after-fork hook, otherwise the child shared the
+parent's file handles and background thread.
+
+In v5 this happens automatically: a `Process._fork` / `Process.daemon` hook calls
+`SemanticLogger.reopen` in the child process. The call is guarded to run once per process.
+
+For most applications you can now **remove** the manual reopen hook, for example:
+
+~~~ruby
+# No longer needed in v5 — handled automatically:
+before_fork { SemanticLogger.flush }
+after_fork  { SemanticLogger.reopen }
+~~~
+
+If you have a reason to manage this yourself (for example you reopen at a very specific point in
+your boot sequence), disable the automatic behaviour:
+
+~~~ruby
+SemanticLogger.reopen_on_fork = false
+~~~
+
+#### Recommended: enable logger caching
+
+By default `SemanticLogger[SomeClass]` returns a **new** `Logger` instance on every call. This means
+that if one part of the code obtains a logger and later changes its `level` (or filter), other
+holders of "the same" logger do not see the change, because they hold different instances.
+
+v5 adds opt-in caching so that a `Class` or `Module` maps to a single shared `Logger` instance:
+
+~~~ruby
+SemanticLogger.cache_loggers = true
+~~~
+
+With caching enabled:
+
+- `SemanticLogger[MyClass]` and the `Loggable` mixin's `MyClass.logger` return the **same** instance.
+- Changing that logger's level or filter is visible to every holder.
+- Strings (`SemanticLogger["Name"]`) always get a fresh instance, and anonymous classes (no `name`)
+  are never cached.
+
+Enabling caching is recommended for most applications. It is opt-in (default `false`) to preserve
+existing behaviour for code that relied on getting an independent logger per call. If you need to
+discard cached loggers (for example in tests, or after redefining a class), call
+`SemanticLogger.clear_logger_cache`.
+
+#### Control characters are escaped in Syslog output
+
+To prevent log-injection via embedded control characters (newlines, escape sequences, etc.), the
+Syslog formatter now escapes control characters in records by default. If you relied on raw control
+characters reaching syslog, this output now differs. The text formatters (default, color) also gain
+an opt-in `escape_control_chars` option (default `false`) for the same protection. See the
+[Security](security.html) page for details.
+
+#### `Formatters::Base#cleanse` renamed
+
+The internal `SemanticLogger::Formatters::Base#cleanse` method was renamed to
+`#escape_control_characters`. This only affects custom formatters or subclasses that called the old
+method name directly; update them to call `#escape_control_characters`.
+
+#### Rails: appenders are now configured in one block
+
+If you use [rails_semantic_logger](rails.html), the companion gem's v5 release moves appender
+configuration into a single `config.rails_semantic_logger.appenders do |appenders| ... end` block.
+The v4 options (`format`, `add_file_appender`, `ap_options`, `filter`, `console_logger`) still work
+but are deprecated and will be removed in v6. See
+[Migrating from v4 to v5](rails.html#migrating-from-v4-to-v5) for the full before/after mapping.
+
+### Upgrading to Semantic Logger v4.18
+
+#### Async queue is now bounded by default
+
+The default `max_queue_size` for async appenders changed from `-1` (unbounded) to `10_000`.
+Under sustained high log volume, messages that exceed the queue limit will be dropped rather than
+causing memory to grow without bound.
+
+If your application logs at very high throughput and you were relying on the unbounded default,
+set the limit explicitly when adding each appender:
+
+~~~ruby
+SemanticLogger.add_appender(io: $stdout, async: true, max_queue_size: -1)
+~~~
+
+Alternatively, tune the value to match your application's tolerance for log loss vs. memory usage.
+
+#### Invalid exception values are now wrapped
+
+Previously, passing a non-`Exception` object to the `exception:` keyword argument would silently
+misbehave. It is now wrapped in an `ArgumentError` with a description of the invalid value and a
+backtrace pointing to the call site:
+
+~~~ruby
+# This previously caused undefined behaviour — now raises a descriptive ArgumentError
+logger.error("Something went wrong", exception: "a plain string")
+~~~
+
+#### New Relic formatter — trace and span metadata
+
+Previously, New Relic trace metadata (`trace.id`, `span.id`, `entity.name`, etc.) was captured at
+format time, so it worked with any appender type. In v4.18, this metadata is captured via an
+`on_log` callback that is only registered when `SemanticLogger::Appender::NewRelicLogs` is
+instantiated.
+
+If you use a plain IO or File appender with `SemanticLogger::Formatters::NewRelicLogs` as the
+formatter (rather than the dedicated `NewRelicLogs` appender), you must register the callback
+manually in your initializer, otherwise `trace.id`, `span.id`, and `entity.name` will be absent
+from all logs:
+
+~~~ruby
+require "semantic_logger/appender/new_relic_logs"
+SemanticLogger.on_log(SemanticLogger::Appender::NewRelicLogs::CAPTURE_CONTEXT)
+~~~
+
+This line should be added before any log messages are emitted.
+
+---
+
+### Upgrading to Semantic Logger v4.17
+
+#### New Relic formatter (breaking changes for New Relic users)
+
+The New Relic log formatter (`SemanticLogger::Formatters::NewRelicLogs`) has been significantly
+updated to produce a structure that New Relic can natively parse and index as individual
+attributes. Most users will benefit from richer log correlation in New Relic, but there are
+several breaking changes to be aware of.
+
+##### Log output structure
+
+Previously, all semantic fields (`payload`, `tags`, `named_tags`, `metric`, etc.) were serialized
+as a JSON string inside the `message` key. They are now emitted as top-level keys:
+
+Before (v4.16):
+~~~json
+{
+  "message": "{\"message\":\"Order processed\",\"payload\":{\"order_id\":123},\"tags\":[],\"named_tags\":{}}",
+  "timestamp": 1234567890000,
+  "log.level": "INFO"
+}
+~~~
+
+After (v4.17):
+~~~json
+{
+  "message": "Order processed",
+  "payload": { "order_id": 123 },
+  "timestamp": 1234567890000,
+  "logger": { "name": "OrderService" },
+  "thread": { "name": "main" }
+}
+~~~
+
+**Impact**: Any New Relic alert queries, dashboards, or NRQL that references fields inside the
+old `message` JSON string (e.g. `message.payload.order_id`) must be updated to reference the
+new top-level keys (e.g. `payload.order_id`).
+
+Note that New Relic's log ingestion flattens nested objects. A `payload` value that is itself a
+nested Hash may not be fully indexed as individually searchable attributes. If you need payload
+fields to be queryable in New Relic, promote them to `named_tags` instead:
+
+~~~ruby
+# Payload fields may not be individually queryable in New Relic:
+logger.info "Order processed", order_id: 123, amount: 49.99
+
+# Use named_tags for fields you want to query directly in New Relic:
+SemanticLogger.tagged(order_id: 123, amount: 49.99) do
+  logger.info "Order processed"
+end
+~~~
+
+##### named_tags are now merged to the top level
+
+Previously `named_tags` were nested inside the `message` JSON string. They are now merged
+directly into the top-level log entry, making them first-class attributes in New Relic.
+
+If a named tag key conflicts with an existing top-level key (e.g. `message`, `timestamp`), it is
+dropped and the conflicting key names are recorded under `named_tag_conflicts`.
+
+##### Error, logger, and thread fields restructured
+
+Before (v4.16):
+~~~json
+{
+  "error.message": "Something went wrong",
+  "error.class":   "RuntimeError",
+  "error.stack":   "...",
+  "log.level":     "ERROR",
+  "logger.name":   "OrderService",
+  "thread.name":   "main"
+}
+~~~
+
+After (v4.17):
+~~~json
+{
+  "error":  { "message": "Something went wrong", "class": "RuntimeError", "stack": "..." },
+  "logger": { "name": "OrderService" },
+  "thread": { "name": "main" }
+}
+~~~
+
+Update any New Relic alert conditions or NRQL queries that reference the old dot-notation keys.
+
+#### Suppressing timestamps in formatters
+
+v4.17 added `:notime` as an explicit `time_format` value to suppress timestamp output. If you
+were previously passing `time_format: nil` expecting it to suppress output, use `:notime` instead:
+
+~~~ruby
+SemanticLogger.add_appender(io: $stdout, formatter: MyFormatter.new(time_format: :notime))
+~~~
+
+---
+
+### Upgrading to Semantic Logger v4.9
+
+These changes should not be noticeable by the majority of users of Semantic Logger, since
+they are to the internal API. It is possible that advanced users may be using these internal
+API's directly.
+
+This does not affect any calls to the public api `SemanticLogger.add_appender`.
+
+File and IO are now separate appenders. When creating the File appender explicitly, its arguments
+have changed. For example, when requesting an IO stream, it needs to be changed from:
+
+~~~ruby
+SemanticLogger::Appender::File.new(io: $stderr)
+~~~
+to:
+~~~ruby
+SemanticLogger::Appender::IO.new($stderr)
+~~~
+
+Additionally, this needs to be changed from:
+~~~ruby
+SemanticLogger::Appender::File.new(file_name: "file.log")
+~~~
+to:
+~~~ruby
+SemanticLogger::Appender::File.new("file.log")
+~~~
+
+Rails Semantic Logger, if used, needs to be upgraded to v4.9 when upgrading to Semantic Logger v4.9.
+
+---
+
+### 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)
+~~~
+
+---
+
+### Upgrading to Semantic Logger v4.0
+
+The following changes need to be made when upgrading to V4:
+- Ruby V2.3 / JRuby V9.1 is now the minimum runtime version.
+- Replace calls to `Logger#with_payload` with `SemanticLogger.named_tagged`.
+- Replace calls to `Logger#payload` with `SemanticLogger.named_tags`.
+- MongoDB Appender requires Mongo Ruby Client V2 or greater.
+- Appenders now write payload data in a separate `:payload` tag instead of mixing them
+  directly into the root elements to avoid name clashes.
+
+As a result any calls like the following:
+
+~~~ruby
+logger.debug foo: 'foo', bar: 'bar'
+~~~
+
+Must be replaced with the following in v4:
+
+~~~ruby
+logger.debug payload: {foo: 'foo', bar: 'bar'}
+~~~
+
+Similarly, for measure blocks:
+
+~~~ruby
+logger.measure_info('How long is the sleep', foo: 'foo', bar: 'bar') { sleep 1 }
+~~~
+
+Must be replaced with the following in v4:
+
+~~~ruby
+logger.measure_info('How long is the sleep', payload: {foo: 'foo', bar: 'bar'}) { sleep 1 }
+~~~
+
+The common log call has not changed, and the payload is still logged directly:
+
+~~~ruby
+logger.debug('log this', foo: 'foo', bar: 'bar')
+~~~

data/lib/semantic_logger/appender/async.rb

@@ -2,28 +2,39 @@ require "forwardable"
 
 module SemanticLogger
   module Appender
-    # Allow any appender to run asynchronously in a separate thread.
+    # Proxy that allows any appender to run asynchronously in a separate thread.
+    #
+    # The worker thread and the in-memory queue are owned by an internal
+    # SemanticLogger::QueueProcessor. This proxy forwards log/flush/close/reopen on to the
+    # processor, and forwards the remaining appender methods (name, level, ...) directly to
+    # the wrapped appender so they keep executing on the caller's thread.
     class Async
       extend Forwardable
 
-      attr_accessor :lag_check_interval, :lag_threshold_s
-      attr_reader :queue, :appender, :max_queue_size
+      attr_reader :appender, :processor
 
-      # Forward methods that can be called directly
-      def_delegator :@appender, :name
-      def_delegator :@appender, :should_log?
-      def_delegator :@appender, :filter
-      def_delegator :@appender, :host
-      def_delegator :@appender, :application
-      def_delegator :@appender, :environment
-      def_delegator :@appender, :level
-      def_delegator :@appender, :level=
-      def_delegator :@appender, :logger
-      def_delegator :@appender, :logger=
+      # Methods forwarded directly to the wrapped appender (run on the caller's thread).
+      def_delegators :@appender,
+                     :name, :should_log?, :filter, :host, :application, :environment,
+                     :level, :level=, :logger, :logger=, :console_stream, :console_output?
+
+      # Methods forwarded to the queue processor that owns the thread and queue.
+      # Tuning options (max_queue_size, batch_size, non_blocking, ...) are set once at
+      # construction via SemanticLogger.add_appender, so only the values that callers actually
+      # read back are re-exposed here. lag_* backs the public SemanticLogger.lag_* API.
+      def_delegators :@processor,
+                     :log, :flush, :close, :thread, :active?, :queue, :max_queue_size,
+                     :capped?, :non_blocking?, :batch?,
+                     :lag_check_interval, :lag_check_interval=,
+                     :lag_threshold_s, :lag_threshold_s=,
+                     :processed_count, :dropped_count
 
       # Appender proxy to allow an existing appender to run asynchronously in a separate thread.
       #
       # Parameters:
+      #   appender: [SemanticLogger::Subscriber]
+      #     The appender to log to in a separate thread.
+      #
       #   max_queue_size: [Integer]
       #     The maximum number of log messages to hold on the queue before blocking attempts to add to the queue.
       #     -1: The queue size is uncapped and will never block no matter how long the queue is.
@@ -36,172 +47,74 @@ module SemanticLogger
       #   lag_check_interval: [Integer]
       #     Number of messages to process before checking for slow logging.
       #     Default: 1,000
-      def initialize(appender:,
-                     max_queue_size: 10_000,
-                     lag_check_interval: 1_000,
-                     lag_threshold_s: 30)
-        @appender           = appender
-        @lag_check_interval = lag_check_interval
-        @lag_threshold_s    = lag_threshold_s
-        @thread             = nil
-        @max_queue_size     = max_queue_size
-        create_queue
-        thread
+      #     Note: Not applicable when batch: true.
+      #
+      #   batch: [true|false]
+      #     Process log messages in batches via the appender's #batch method, instead of one at a time.
+      #     The appender must implement #batch.
+      #     Default: false
+      #
+      #   batch_size: [Integer]
+      #     Maximum number of messages to batch up before sending.
+      #     Default: 300
+      #     Note: Only applicable when batch: true.
+      #
+      #   batch_seconds: [Integer]
+      #     Maximum number of seconds between sending batches.
+      #     Default: 5
+      #     Note: Only applicable when batch: true.
+      #
+      #   non_blocking: [true|false]
+      #     Whether to drop log messages instead of blocking the calling thread when the queue is full.
+      #     When true and the queue is capped, attempts to add to a full queue return immediately and
+      #     the message is dropped. The number of dropped messages is logged to the internal logger
+      #     periodically (see dropped_message_report_seconds). Only applies to a capped queue.
+      #     Default: false
+      #
+      #   dropped_message_report_seconds: [Integer]
+      #     When non_blocking is enabled, log the count of dropped messages to the internal logger
+      #     at most once every this number of seconds.
+      #     Default: 30
+      #
+      #   async_max_retries: [Integer]
+      #     Maximum number of consecutive times to restart the worker thread (with a back-off)
+      #     after it raises an exception while processing messages, before giving up and stopping
+      #     the thread. The counter resets after any message is processed successfully.
+      #     -1: Retry indefinitely and never stop the thread (the pre-v5 behaviour).
+      #     Default: 100
+      def initialize(appender:, **args)
+        @appender  = appender
+        @processor = QueueProcessor.start(appender: appender, **args)
       end
 
-      # Re-open appender after a fork
+      # Re-open appender after a fork.
       def reopen
-        # Workaround CRuby crash on fork by recreating queue on reopen
-        #   https://github.com/reidmorrison/semantic_logger/issues/103
-        @queue&.close
-        create_queue
-
         appender.reopen if appender.respond_to?(:reopen)
-
-        @thread&.kill if @thread&.alive?
-        @thread = Thread.new { process }
-      end
-
-      # Returns [true|false] if the queue has a capped size.
-      def capped?
-        @capped
+        processor.reopen
       end
 
-      # Returns [Thread] the worker thread.
+      # Returns [Hash] operational statistics for this appender.
       #
-      # Starts the worker thread if not running.
-      def thread
-        return @thread if @thread&.alive?
-
-        @thread = Thread.new { process }
-      end
-
-      # Returns true if the worker thread is active
-      def active?
-        @thread&.alive?
-      end
-
-      # Add log message for processing.
-      def log(log)
-        queue << log
-      end
-
-      # Flush all queued log entries disk, database, etc.
-      #  All queued log messages are written and then each appender is flushed in turn.
-      def flush
-        submit_request(:flush)
-      end
-
-      # Close all appenders and flush any outstanding messages.
-      def close
-        # TODO: Prevent new close requests once this appender has been closed.
-        submit_request(:close)
-      end
-
-      private
-
-      def create_queue
-        if max_queue_size == -1
-          @queue  = Queue.new
-          @capped = false
-        else
-          @queue  = SizedQueue.new(max_queue_size)
-          @capped = true
-        end
-      end
-
-      # Separate thread for batching up log messages before writing.
-      def process
-        # This thread is designed to never go down unless the main thread terminates
-        # or the appender is closed.
-        Thread.current.name = logger.name
-        logger.trace "Async: Appender thread active"
-        begin
-          process_messages
-        rescue StandardError => e
-          # This block may be called after the file handles have been released by Ruby
-          begin
-            logger.error("Async: Restarting due to exception", e)
-          rescue StandardError
-            nil
-          end
-          retry
-        rescue Exception => e
-          # This block may be called after the file handles have been released by Ruby
-          begin
-            logger.error("Async: Stopping due to fatal exception", e)
-          rescue StandardError
-            nil
-          end
-        ensure
-          @thread = nil
-          # This block may be called after the file handles have been released by Ruby
-          begin
-            logger.trace("Async: Thread has stopped")
-          rescue StandardError
-            nil
-          end
-        end
-      end
-
-      def process_messages
-        count = 0
-        while (message = queue.pop)
-          if message.is_a?(Log)
-            appender.log(message)
-            count += 1
-            # Check every few log messages whether this appender thread is falling behind
-            if count > lag_check_interval
-              check_lag(message)
-              count = 0
-            end
-          else
-            break unless process_message(message)
-          end
-        end
-        logger.trace "Async: Queue Closed"
-      end
-
-      # Returns false when message processing should be stopped
-      def process_message(message)
-        case message[:command]
-        when :flush
-          appender.flush
-          message[:reply_queue] << true if message[:reply_queue]
-        when :close
-          appender.close
-          message[:reply_queue] << true if message[:reply_queue]
-          return false
-        else
-          logger.warn "Async: Appender thread: Ignoring unknown command: #{message[:command]}"
-        end
-        true
-      end
-
-      def check_lag(log)
-        diff = Time.now - log.time
-        return unless diff > lag_threshold_s
-
-        logger.warn "Async: Appender thread has fallen behind by #{diff} seconds with #{queue.size} messages queued up. Consider reducing the log level or changing the appenders"
-      end
-
-      # Submit command and wait for reply
-      def submit_request(command)
-        return false unless active?
-
-        queue_size = queue.size
-        msg        = "Async: Queued log messages: #{queue_size}, running command: #{command}"
-        if queue_size > 1_000
-          logger.warn msg
-        elsif queue_size > 100
-          logger.info msg
-        elsif queue_size.positive?
-          logger.trace msg
-        end
-
-        reply_queue = Queue.new
-        queue << {command: command, reply_queue: reply_queue}
-        reply_queue.pop
+      #   name:           [String]  Name of the wrapped appender.
+      #   async:          [true]    This appender logs asynchronously via a separate thread.
+      #   thread_active:  [Boolean] Whether the worker thread is currently running.
+      #   queue_size:     [Integer] Number of log messages currently waiting to be written.
+      #   capped:         [Boolean] Whether the queue has a maximum size.
+      #   max_queue_size: [Integer] Maximum queue size, or nil when uncapped.
+      #   processed:      [Integer] Cumulative number of log messages written since startup.
+      #   dropped:        [Integer] Cumulative number of log messages dropped because the queue
+      #                             was full (only possible when non_blocking is enabled).
+      def stats
+        {
+          name:           name,
+          async:          true,
+          thread_active:  active? || false,
+          queue_size:     queue.size,
+          capped:         capped?,
+          max_queue_size: capped? ? max_queue_size : nil,
+          processed:      processed_count,
+          dropped:        dropped_count
+        }
       end
     end
   end