semantic_logger 5.0.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/cloudwatch_logs.rb

@@ -2,7 +2,8 @@ begin
   require "aws-sdk-cloudwatchlogs"
 rescue LoadError
   raise LoadError,
-        'Gem aws-sdk-cloudwatchlogs is required for logging to CloudWatch Logs. Please add the gem "aws-sdk-cloudwatchlogs" to your Gemfile.'
+        "Gem aws-sdk-cloudwatchlogs is required for logging to CloudWatch Logs. " \
+        'Please add the gem "aws-sdk-cloudwatchlogs" to your Gemfile.'
 end
 
 require "concurrent"
@@ -20,7 +21,8 @@ require "concurrent"
 module SemanticLogger
   module Appender
     class CloudwatchLogs < SemanticLogger::Subscriber
-      attr_reader :client_kwargs, :group, :create_group, :create_stream, :force_flush_interval_seconds, :max_buffered_events,
+      attr_reader :client_kwargs, :group, :create_group, :create_stream,
+                  :force_flush_interval_seconds, :max_buffered_events,
                   :task, :client, :buffered_logs
 
       # Create CloudWatch Logs Appender

data/lib/semantic_logger/appender/elasticsearch.rb

@@ -2,7 +2,8 @@ begin
   require "elasticsearch"
 rescue LoadError
   raise LoadError,
-        'Gem elasticsearch is required for logging to Elasticsearch. Please add the gem "elasticsearch" to your Gemfile.'
+        "Gem elasticsearch is required for logging to Elasticsearch. " \
+        'Please add the gem "elasticsearch" to your Gemfile.'
 end
 
 require "semantic_logger/appender/elasticsearch_base"
@@ -26,10 +27,6 @@ module SemanticLogger
       def client_class
         ::Elasticsearch::Client
       end
-
-      def version_supports_type?
-        Gem::Version.new(::Elasticsearch::VERSION) < Gem::Version.new(7)
-      end
     end
   end
 end

data/lib/semantic_logger/appender/elasticsearch_base.rb

@@ -6,14 +6,13 @@ module SemanticLogger
     #
     # Implements the shared bulk-indexing pipeline used by both the
     # {Elasticsearch} and {OpenSearch} appenders. Subclasses only need to
-    # supply the backing client class (and, optionally, whether the server
-    # version still supports document `_type`).
+    # supply the backing client class.
     #
     # This class is internal: applications add an appender via
     # `SemanticLogger.add_appender(appender: :elasticsearch, ...)` or
     # `appender: :opensearch`, never by referencing this class directly.
     class ElasticsearchBase < SemanticLogger::Subscriber
-      attr_accessor :url, :index, :date_pattern, :type, :client, :flush_interval, :timeout_interval, :batch_size,
+      attr_accessor :url, :index, :date_pattern, :client, :flush_interval, :timeout_interval, :batch_size,
                     :client_args
 
       # Create an Elasticsearch-compatible appender over persistent HTTP(S).
@@ -31,9 +30,9 @@ module SemanticLogger
       #     Default: '%Y.%m.%d'
       #
       #   type: [String]
-      #     Document type to associate with logs when they are written.
-      #     Deprecated in Elasticsearch 7.0.0, unused by OpenSearch.
-      #     Default: 'log'
+      #     Deprecated and ignored. Document `_type` has been unused since
+      #     Elasticsearch 7 and is ignored by OpenSearch. Passing it logs a
+      #     deprecation warning; it will be removed in v6.
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
       #     Override the log level for this appender.
@@ -124,7 +123,7 @@ module SemanticLogger
       def initialize(url: "http://localhost:9200",
                      index: "semantic_logger",
                      date_pattern: "%Y.%m.%d",
-                     type: "log",
+                     type: nil,
                      level: nil,
                      formatter: nil,
                      filter: nil,
@@ -134,16 +133,24 @@ module SemanticLogger
                      data_stream: false,
                      **client_args,
                      &)
+        if type
+          Kernel.warn(
+            "The Elasticsearch/OpenSearch appender `type:` parameter is deprecated and will be removed in v6. " \
+            "Document `_type` has been unused since Elasticsearch 7 and is ignored by OpenSearch.",
+            category: :deprecated
+          )
+        end
+
         @url                  = url
         @index                = index
         @date_pattern         = date_pattern
-        @type                 = type
         @client_args          = client_args.dup
         @client_args[:url]    = url if url && !client_args[:hosts]
         @client_args[:logger] = logger
         @data_stream          = data_stream
 
-        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: false, &)
+        super(level: level, formatter: formatter, filter: filter, application: application,
+              environment: environment, host: host, metrics: false, &)
         reopen
       end
 
@@ -193,20 +200,13 @@ module SemanticLogger
         expanded_index_name = log.time.strftime("#{index}-#{date_pattern}")
         return {"create" => {}} if @data_stream
 
-        bulk_index = {"index" => {"_index" => expanded_index_name}}
-        bulk_index["index"].merge!({"_type" => type}) if version_supports_type?
-        bulk_index
+        {"index" => {"_index" => expanded_index_name}}
       end
 
       def default_formatter
         time_key = @data_stream ? "@timestamp" : :timestamp
         SemanticLogger::Formatters::Raw.new(time_format: :iso_8601, time_key: time_key)
       end
-
-      # Modern Elasticsearch (>= 7) and OpenSearch no longer support document `_type`.
-      def version_supports_type?
-        false
-      end
     end
   end
 end

data/lib/semantic_logger/appender/elasticsearch_http.rb

@@ -13,7 +13,7 @@ require "date"
 module SemanticLogger
   module Appender
     class ElasticsearchHttp < SemanticLogger::Appender::Http
-      attr_accessor :index, :type
+      attr_accessor :index
 
       # Create Elasticsearch appender over persistent HTTP(S)
       #
@@ -25,9 +25,9 @@ module SemanticLogger
       #     Default: 'semantic_logger'
       #
       #   type: [String]
-      #     Document type to associate with logs when they are written.
-      #     Deprecated in Elasticsearch 7.0.0
-      #     Default: 'log'
+      #     Deprecated and ignored. Document `_type` has been unused since
+      #     Elasticsearch 7. Passing it logs a deprecation warning; it will be
+      #     removed in v6.
       #
       #   level: [:trace | :debug | :info | :warn | :error | :fatal]
       #     Override the log level for this appender.
@@ -52,16 +52,23 @@ module SemanticLogger
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
       def initialize(index: "semantic_logger",
-                     type: "log",
+                     type: nil,
                      url: "http://localhost:9200",
                      **http_args,
                      &)
+        if type
+          Kernel.warn(
+            "The Elasticsearch/OpenSearch appender `type:` parameter is deprecated and will be removed in v6. " \
+            "Document `_type` has been unused since Elasticsearch 7 and is ignored by OpenSearch.",
+            category: :deprecated
+          )
+        end
+
         @index = index
-        @type  = type
         super(url: url, **http_args, &)
 
         @request_path = "#{@path.end_with?('/') ? @path : "#{@path}/"}#{@index}-%Y.%m.%d"
-        @logging_path = "#{@request_path}/#{type}"
+        @logging_path = "#{@request_path}/_doc"
       end
 
       # Log to the index for today.

data/lib/semantic_logger/appender/file.rb

@@ -150,6 +150,11 @@ module SemanticLogger
         @reopen_at      = nil
 
         super(**args, &)
+
+        # Open the file at creation time so that misconfiguration (bad directory,
+        # insufficient permissions, ...) raises immediately in SemanticLogger.add_appender,
+        # instead of surfacing later on the appender thread via the internal logger.
+        reopen
       end
 
       # After forking an active process call #reopen to re-open

data/lib/semantic_logger/appender/new_relic.rb

@@ -33,6 +33,12 @@ module SemanticLogger
       #     Proc: Only include log messages where the supplied Proc returns true
       #           The Proc must return true or false.
       def initialize(level: :error, **args, &block)
+        Kernel.warn(
+          "SemanticLogger::Appender::NewRelic (appender: :new_relic) is deprecated and will be removed in v6. " \
+          "It reports errors via newrelic_rpm and is superseded by the log-forwarding appender " \
+          "appender: :new_relic_logs.",
+          category: :deprecated
+        )
         super
       end
 

data/lib/semantic_logger/appender/new_relic_logs.rb

@@ -48,7 +48,8 @@ module SemanticLogger
       def initialize(formatter: SemanticLogger::Formatters::NewRelicLogs.new, **args, &block)
         super
 
-        # Record NewRelic's "trace.id"/"entity.name"/"hostname"/etc, so we can include them later in the formatted output.
+        # Record NewRelic's "trace.id"/"entity.name"/"hostname"/etc, so we can include them
+        # later in the formatted output.
         # These are thread-local, so need to be captured as soon as the log-message is created.
         # https://rubydoc.info/gems/newrelic_rpm/NewRelic/Agent#linking_metadata-instance_method
         SemanticLogger.on_log(CAPTURE_CONTEXT)

data/lib/semantic_logger/appender/open_telemetry.rb

@@ -2,7 +2,8 @@ begin
   require "opentelemetry/logs"
 rescue LoadError
   raise LoadError,
-        'Gem opentelemetry-logs-sdk is required for logging to Open Telemetry. Please add the gem "opentelemetry-logs-sdk" to your Gemfile.'
+        "Gem opentelemetry-logs-sdk is required for logging to Open Telemetry. " \
+        'Please add the gem "opentelemetry-logs-sdk" to your Gemfile.'
 end
 
 # Open Telemetry Appender

data/lib/semantic_logger/appender/opensearch.rb

@@ -2,7 +2,8 @@ begin
   require "opensearch-ruby"
 rescue LoadError
   raise LoadError,
-        'Gem opensearch-ruby is required for logging to OpenSearch. Please add the gem "opensearch-ruby" to your Gemfile.'
+        "Gem opensearch-ruby is required for logging to OpenSearch. " \
+        'Please add the gem "opensearch-ruby" to your Gemfile.'
 end
 
 require "semantic_logger/appender/elasticsearch_base"

data/lib/semantic_logger/appender/rabbitmq.rb

@@ -81,14 +81,15 @@ module SemanticLogger
       #
       #   more parameters supported by Bunny: http://rubybunny.info/articles/connecting.html
       def initialize(queue_name: "semantic_logger", rabbitmq_host: nil,
-                     level: nil, formatter: nil, filter: nil, application: nil, environment: nil, host: nil, metrics: true,
-                     **args, &)
+                     level: nil, formatter: nil, filter: nil, application: nil, environment: nil,
+                     host: nil, metrics: true, **args, &)
         @queue_name             = queue_name
         @rabbitmq_args          = args.dup
         @rabbitmq_args[:host]   = rabbitmq_host
         @rabbitmq_args[:logger] = logger
 
-        super(level: level, formatter: formatter, filter: filter, application: application, environment: environment, host: host, metrics: metrics, &)
+        super(level: level, formatter: formatter, filter: filter, application: application,
+              environment: environment, host: host, metrics: metrics, &)
         reopen
       end
 

data/lib/semantic_logger/appender/sentry.rb

@@ -39,6 +39,11 @@ module SemanticLogger
       #     Name of this application to appear in log messages.
       #     Default: SemanticLogger.application
       def initialize(level: :error, **args, &block)
+        Kernel.warn(
+          "SemanticLogger::Appender::Sentry (appender: :sentry) is deprecated and will be removed in v6. " \
+          "It depends on the end-of-life sentry-raven gem. Use appender: :sentry_ruby instead.",
+          category: :deprecated
+        )
         # Replace the Sentry Raven logger so that we can identify its log messages and not forward them to Sentry
         Raven.configure { |config| config.logger = SemanticLogger[Raven] }
         super