scout_apm_logging 2.0.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7064d80f9892529f81a77b0e46f9e517e8ea96f8e9e53880ee2eefd6c5abbf2
-  data.tar.gz: 3a3ec083c05435e99d23b719bbc31f38d7ce4a07ddcf25ef47fed544147ea21c
+  metadata.gz: e3e6660d99d9d31d6e78ba6ef801432d582a5a9fe78917d8b027a8cfae85e834
+  data.tar.gz: 37fd12719798598626ac9d97bfd3c13d186be2d54a0e6ac86b572ecc246c31b1
 SHA512:
-  metadata.gz: d7ea291371355544a94b69d3ab7ad75ee7407c84d450bb3e9a44ce6aabfa6bb2c27ce5813276111fb6584268eaba59875d346bd6b36b83c4db0d153478f7ba9f
-  data.tar.gz: ff9ee96494248654b146c2cc9d45cc7db960196781661cc94e3f79ebbabde83930b4c264e67c0270cd24e1510027242b62e307cda061b26e1b2789d1af5f7941
+  metadata.gz: 3ef2d0cb82f91cdfb640b4eed871e1b3505af4eead81317182bb53e53858ce009dccdc693227cafdc7ceffca21d9be3f95f089e34f4d1945a48599ca568e64bc
+  data.tar.gz: eadfd1cbd5ab6f204fbc5d8b087164c01ed7f532a33d5841b658143aeb0abda19c20d22dce4a2e827ebc4caca53c9c1830c83923185d8b103edc463805162cd3

data/.github/workflows/release.yml

@@ -0,0 +1,30 @@
+name: Release Gem
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+# Directly from https://github.com/rubygems/release-gem/tree/v1
+# Predicated on Tag Ruleset preventing arbitrary tag creation and
+# requiring checks to pass for commit before tag creation
+jobs:
+  push:
+    name: Push gem to RubyGems.org
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
+      contents: write # IMPORTANT: this permission is required for `rake release` to push the release tag
+
+    steps:
+      # Set up
+      - uses: actions/checkout@v4
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+          ruby-version: ruby
+
+      # Release
+      - uses: rubygems/release-gem@v1

data/.github/workflows/test.yml

@@ -8,11 +8,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2', '3.3', '3.4']
+        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2', '3.3', '3.4', '4.0']
     env:
       DOCKER_RUBY_VERSION: ${{ matrix.ruby }}
       BUNDLE_GEMFILE: gems/rails.gemfile
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - name: Extract Library Version
@@ -21,21 +21,26 @@ jobs:
           echo "LIBRARY_VERSION=$VERSION" >> $GITHUB_ENV
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
-        if: ${{ (env.LIBRARY_VERSION == '1' && !contains(fromJson('["3.4"]'), matrix.ruby)) ||
-                 (env.LIBRARY_VERSION == '2' && !contains(fromJson('["2.6", "2.7", "3.0"]'), matrix.ruby)) }}
+        if: ${{ (env.LIBRARY_VERSION == '1' && !startsWith(matrix.ruby, '3.4') && !startsWith(matrix.ruby, '4.')) || (env.LIBRARY_VERSION == '2' && !startsWith(matrix.ruby, '2.6') && !startsWith(matrix.ruby, '2.7') && !startsWith(matrix.ruby, '3.0')) }}
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
       - name: Run RSpec
         run: |
-          if [[ "$LIBRARY_VERSION" == "1" && ("${{ matrix.ruby }}" == "3.4" ) ]]; then
-            echo "Skipping Ruby ${{ matrix.ruby }} for Library v1.x"
+          RUBY="${{ matrix.ruby }}"
+
+          # Library v1: block Ruby >= 3.4 (3.4, 4.x, 5.x, ...)
+          if [[ "$LIBRARY_VERSION" == "1" && ( "$RUBY" == 3.4* || "$RUBY" == 4.* || "$RUBY" == 5.* ) ]]; then
+            echo "Skipping Ruby $RUBY for Library v1.x (>= 3.4 unsupported)"
             exit 0
           fi
-          if [[ "$LIBRARY_VERSION" == "2" && ( "${{ matrix.ruby }}" == "2.6" || "${{ matrix.ruby }}" == "2.7" || "${{ matrix.ruby }}" == "3.0" ) ]]; then
-            echo "Skipping Ruby ${{ matrix.ruby }} for Library v2.x"
+
+          # Library v2: block specific old Rubies
+          if [[ "$LIBRARY_VERSION" == "2" && ( "$RUBY" == 2.6* || "$RUBY" == 2.7* || "$RUBY" == 3.0* ) ]]; then
+            echo "Skipping Ruby $RUBY for Library v2.x"
             exit 0
           fi
+
           bundle exec rake test
 
   rubocop:

data/.rubocop.yml

@@ -12,6 +12,7 @@ AllCops:
 
 Metrics/BlockLength:
   Exclude:
+    - "scout_apm_logging.gemspec"
     - "spec/**/*"
 
 Metrics/ClassLength:

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## 2.2.0
+* Fix severity numbers sent with `opentelemetry-exporter-otlp-logs` >= 0.7.0 (Ruby levels were sent instead of OpenTelemetry levels).
+  * See [#119](https://github.com/scoutapp/scout_apm_ruby_logging/pull/119).
+* Remove the OTLP exporter monkey patch; severity is now mapped when the log is emitted.
+* Replace the [#114](https://github.com/scoutapp/scout_apm_ruby_logging/pull/114) guard with a small `LogRecordData` shim, so mismatched `opentelemetry-exporter-otlp-logs` / `opentelemetry-logs-sdk` versions no longer drop logs.
+* Declare `opentelemetry-logs-api` as a direct dependency.
+* Fix `logger.unknown` raising `NameError`; it is now sent as FATAL.
+* Fix logging text that isn't valid UTF-8 raising an error; invalid bytes are now replaced. Thanks @rpearce!
+  * See [#120](https://github.com/scoutapp/scout_apm_ruby_logging/pull/120).
+* Add release workflow for publishing to RubyGems with trusted publishing.
+
+## 2.1.1
+* Fix all logs being dropped with `opentelemetry-logs-sdk` >= 0.7.0. Thanks @rpearce!
+  * See [#114](https://github.com/scoutapp/scout_apm_ruby_logging/pull/114).
+* Add Ruby 4.0 to test matrix.
+
+## 2.1.0
+* Add ability to capture log line with logs.
+  * `logs_capture_log_line: true`
+* Add ability to capture stack trace with logs.
+  * `logs_capture_call_stack: true`
+  * See [#98](https://github.com/scoutapp/scout_apm_ruby_logging/pull/98) for benchmarks.
+* Add ability to disable warn message on method_missing.
+  * `logs_method_missing_warning: false`
+* Add ability to log stack trace on method_missing.
+  * `logs_method_missing_call_stack: true`
+* Add tests for ActionCable.
+
 ## 2.0.0
 * Remove vendored opentelmetry SDK.
 * Add support for Ruby 3.4.

data/README.md

@@ -28,10 +28,14 @@ Update your [RAILS_ROOT/config/scout_apm.yml](https://scoutapm.com/apps/new_ruby
 
   logs_monitor: true
   logs_ingest_key: ...
+  logs_capture_level: debug
 ```
 
 Deploy :rocket:
 
+## Docs
+For a complete list of configurations as well as additional information, visit our [docs](https://scoutapm.com/docs/ruby/log-management).
+
 ## Versions
 We currently maintain two versions: 2.x (Ruby 3.1+) and 1.x (2.6-3.3). These versions/branches have feature parity and a similar release cadence.
 
@@ -50,7 +54,7 @@ bundle exec rake test file=/path/to/spec/_spec.rb
 
 To run test(s) against a specific Ruby version:
 ```ruby
-DOCKER_RUBY_VERSION=3.4 bundle exec rake test
+DOCKER_RUBY_VERSION=4.0 bundle exec rake test
 ```
 
 ## Local

data/lib/scout_apm/logging/config.rb

@@ -19,19 +19,12 @@
 # logs_config        - a hash of configuration options for merging into the collector's config
 # logs_reporting_endpoint - the endpoint to send logs to
 # logs_proxy_log_dir - the directory to store logs in for monitoring
-# manager_lock_file  - the location for obtaining an exclusive lock for running monitor manager
-# monitor_pid_file   - the location of the pid file for the monitor
-# monitor_state_file - the location of the state file for the monitor
-# monitor_interval   - the interval to check the collector healtcheck and for new state logs
-# monitor_interval_delay - the delay to wait before running the first monitor interval
-# collector_log_level - the log level for the collector
-# collector_sending_queue_storage_dir - the directory to store queue files
-# collector_offset_storage_dir - the directory to store offset files
-# collector_pid_file - the location of the pid file for the collector
-# collector_download_dir - the directory to store downloaded collector files
-# collector_config_file - the location of the config file for the collector
-# collector_version - the version of the collector to download
-# health_check_port - the port to use for the collector health check. Default is dynamically derived based on port availability
+# logs_capture_call_stack - true or false. If true, capture the call stack for each log message
+# logs_capture_log_line - true or false. If true, capture the log line for each log message
+# logs_call_stack_search_depth - the number of frames to search in the call stack
+# logs_call_stack_capture_depth - the number of frames to capture in the call stack
+# logs_method_missing_warning - true or false. If true, log a warning when method_missing is called
+# logs_method_missing_call_stack -  true or false. If true, capture the call stack when method_missing is called
 #
 # Any of these config settings can be set with an environment variable prefixed
 # by SCOUT_ and uppercasing the key: SCOUT_LOG_LEVEL for instance.
@@ -55,11 +48,23 @@ module ScoutApm
         logs_reporting_endpoint_http
         logs_proxy_log_dir
         logs_log_file_size
+        logs_capture_call_stack
+        logs_capture_log_line
+        logs_call_stack_search_depth
+        logs_call_stack_capture_depth
+        logs_method_missing_warning
+        logs_method_missing_call_stack
       ].freeze
 
       SETTING_COERCIONS = {
         'logs_monitor' => BooleanCoercion.new,
-        'logs_log_file_size' => IntegerCoercion.new
+        'logs_capture_call_stack' => BooleanCoercion.new,
+        'logs_capture_log_line' => BooleanCoercion.new,
+        'logs_call_stack_search_depth' => IntegerCoercion.new,
+        'logs_call_stack_capture_depth' => IntegerCoercion.new,
+        'logs_log_file_size' => IntegerCoercion.new,
+        'logs_method_missing_warning' => BooleanCoercion.new,
+        'logs_method_missing_call_stack' => BooleanCoercion.new
       }.freeze
 
       # The bootstrapped, and initial config that we attach to the context. Will be swapped out by
@@ -117,7 +122,13 @@ module ScoutApm
           'logs_reporting_endpoint' => 'https://otlp.scoutotel.com:4317',
           'logs_reporting_endpoint_http' => 'https://otlp.scoutotel.com:4318/v1/logs',
           'logs_proxy_log_dir' => '/tmp/scout_apm/logs/',
-          'logs_log_file_size' => 1024 * 1024 * 10
+          'logs_log_file_size' => 1024 * 1024 * 10,
+          'logs_capture_call_stack' => false,
+          'logs_capture_log_line' => false,
+          'logs_call_stack_search_depth' => 15,
+          'logs_call_stack_capture_depth' => 2,
+          'logs_method_missing_warning' => true,
+          'logs_method_missing_call_stack' => false
         }.freeze
 
         def value(key)

data/lib/scout_apm/logging/context.rb

@@ -7,6 +7,14 @@ module ScoutApm
       # The root of the application.
       attr_accessor :application_root
 
+      # Use this as the entrypoint.
+      def self.instance
+        @@instance ||= new.tap do |instance|
+          instance.config = ScoutApm::Logging::Config.with_file(instance, instance.config.value('config_file'))
+          instance.config.log_settings(instance.logger)
+        end
+      end
+
       # Initially start up without attempting to load a configuration file. We
       # need to be able to lookup configuration options like "application_root"
       # which would then in turn influence where the yaml configuration file is

data/lib/scout_apm/logging/loggers/capture.rb

@@ -56,7 +56,7 @@ module ScoutApm
           # Re-extend TaggedLogging to verify the patch is be applied.
           # This appears to be an issue in Ruby 2.7 with the broadcast logger.
           ruby_version = Gem::Version.new(RUBY_VERSION)
-          isruby27 = (ruby_version >= Gem::Version.new('2.7') && ruby_version < Gem::Version.new('3.0'))
+          isruby27 = ruby_version >= Gem::Version.new('2.7') && ruby_version < Gem::Version.new('3.0')
           return unless isruby27 && ::Rails.logger.respond_to?(:broadcasts)
 
           ::Rails.logger.broadcasts.each do |logger|

data/lib/scout_apm/logging/loggers/formatter.rb

@@ -3,6 +3,7 @@
 require 'json'
 require 'logger'
 
+require 'opentelemetry-logs-api'
 require 'scout_apm'
 
 module ScoutApm
@@ -12,40 +13,67 @@ module ScoutApm
       class Formatter < ::Logger::Formatter
         DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S.%LZ'
 
-        def call(severity, time, progname, msg) # rubocop:disable Metrics/AbcSize
+        # Ruby's Logger::Severity integers (0..5) do not match OpenTelemetry's
+        # SeverityNumber scale. Emit the OTel value directly so the exporter can
+        # pass it straight through without a patch. Logger labels UNKNOWN as
+        # 'ANY'; it ranks above FATAL, so keep it at the top of the scale.
+        SEVERITY_NUMBER_MAP = {
+          'DEBUG' => ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_DEBUG,
+          'INFO' => ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_INFO,
+          'WARN' => ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_WARN,
+          'ERROR' => ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_ERROR,
+          'FATAL' => ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_FATAL,
+          'ANY' => ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_FATAL
+        }.freeze
+
+        def call(severity, time, progname, msg)
           attributes_to_log = {
             severity:,
             time: format_datetime(time),
             msg: msg2str(msg)
           }
 
+          log_location = Thread.current[:scout_log_location]
+
           attributes_to_log[:progname] = progname if progname
           attributes_to_log['service.name'] = service_name
+          attributes_to_log['log_location'] = log_location if log_location
 
           attributes_to_log.merge!(scout_transaction_id)
           attributes_to_log.merge!(scout_layer)
           attributes_to_log.merge!(scout_context)
-          # Naive local benchmarks show this takes around 200 microseconds. As such, we only apply it to WARN and above.
-          attributes_to_log.merge!(local_log_location) if ::Logger::Severity.const_get(severity) >= ::Logger::Severity::WARN
 
-          message = "#{attributes_to_log.to_json}\n"
+          emit_log(msg, severity, time, attributes_to_log)
+
+          "#{attributes_to_log.to_json}\n"
+        end
+
+        private
+
+        # to_json raises on binary or invalid text, and the raise escapes the log call.
+        def msg2str(msg)
+          text = super
+          return text if text.valid_encoding? && text.encoding != Encoding::BINARY
+
+          text.dup.force_encoding(Encoding::UTF_8).scrub
+        end
 
+        def emit_log(msg, severity, time, attributes_to_log)
           ScoutApm::Logging::Loggers::OpenTelemetry.logger_provider.logger(
             name: 'scout_apm',
             version: '0.1.0'
           ).on_emit(
             severity_text: severity,
-            severity_number: ::Logger::Severity.const_get(severity),
+            severity_number: SEVERITY_NUMBER_MAP.fetch(
+              severity, ::OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_UNSPECIFIED
+            ),
             attributes: attributes_to_log.transform_keys(&:to_s),
             timestamp: time,
-            body: msg,
+            body: msg.is_a?(String) ? attributes_to_log[:msg] : msg,
             context: ::OpenTelemetry::Context.current
           )
-          message
         end
 
-        private
-
         def format_datetime(time)
           time.utc.strftime(DATETIME_FORMAT)
         end
@@ -103,15 +131,6 @@ module ScoutApm
           { "scout_transaction_id": ScoutApm::RequestManager.lookup.transaction_id }
         end
 
-        def local_log_location
-          # Should give us the last local stack which called the log within just the last couple frames.
-          last_local_location = caller[0..15].find { |path| path.include?(Rails.root.to_s) }
-
-          return {} unless last_local_location
-
-          { 'log_location' => last_local_location }
-        end
-
         def context
           ScoutApm::Logging::Context.new.tap do |context|
             context.config = ScoutApm::Logging::Config.with_file(context, context.config.value('config_file'))

data/lib/scout_apm/logging/loggers/logger.rb

@@ -7,6 +7,70 @@ module ScoutApm
       class FileLogger < ::Logger
         include ::ActiveSupport::LoggerSilence if const_defined?('::ActiveSupport::LoggerSilence')
 
+        def initialize(*args, **kwargs, &block)
+          if ScoutApm::Logging::Context.instance.config.value('logs_capture_log_line')
+            self.class.send(:alias_method, :debug, :debug_patched)
+            self.class.send(:alias_method, :info, :info_patched)
+            self.class.send(:alias_method, :warn, :warn_patched)
+            self.class.send(:alias_method, :error, :error_patched)
+            self.class.send(:alias_method, :fatal, :fatal_patched)
+            self.class.send(:alias_method, :unknown, :unknown_patched)
+          end
+
+          super(*args, **kwargs, &block)
+        end
+
+        # Taken from ::Logger. Progname becomes message if no block is given.
+        def debug_patched(progname = nil, &block)
+          return true if level > DEBUG
+
+          # short circuit the block to update the message. #add would eventually call it.
+          # https://github.com/ruby/logger/blob/v1.7.0/lib/logger.rb#L675
+          progname = yield if block_given?
+          progname = add_log_file_and_line_to_message(progname) if progname
+          add(DEBUG, progname, nil, &block)
+        end
+
+        def info_patched(progname = nil, &block)
+          return true if level > INFO
+
+          progname = yield if block_given?
+          progname = add_log_file_and_line_to_message(progname) if progname
+          add(INFO, progname, nil, &block)
+        end
+
+        def warn_patched(progname = nil, &block)
+          return true if level > WARN
+
+          progname = yield if block_given?
+          progname = add_log_file_and_line_to_message(progname) if progname
+          add(WARN, progname, nil, &block)
+        end
+
+        def error_patched(progname = nil, &block)
+          return true if level > ERROR
+
+          progname = yield if block_given?
+          progname = add_log_file_and_line_to_message(progname) if progname
+          add(ERROR, progname, nil, &block)
+        end
+
+        def fatal_patched(progname = nil, &block)
+          return true if level > FATAL
+
+          progname = yield if block_given?
+          progname = add_log_file_and_line_to_message(progname) if progname
+          add(FATAL, progname, nil, &block)
+        end
+
+        def unknown_patched(progname = nil, &block)
+          return true if level > UNKNOWN
+
+          progname = yield if block_given?
+          progname = add_log_file_and_line_to_message(progname) if progname
+          add(UNKNOWN, progname, nil, &block)
+        end
+
         # Other loggers may be extended with additional methods that have not been applied to this file logger.
         # Most likely, these methods will still utilize the exiting logging methods to write to the IO device,
         # however, if this is not the case we may miss logs. With that being said, we shouldn't impact the original
@@ -14,13 +78,75 @@ module ScoutApm
         def method_missing(name, *_args)
           return unless defined?(::Rails)
 
-          ::Rails.logger.warn("Method #{name} called on ScoutApm::Logging::Loggers::FileLogger, but it is not defined.")
+          return unless ScoutApm::Logging::Context.instance.config.value('logs_method_missing_warning')
+
+          if ScoutApm::Logging::Context.instance.config.value('logs_method_missing_call_stack')
+            cs = caller_locations(0, 20)
+            ::Rails.logger.warn("Method #{name} called on ScoutApm::Logging::Loggers::FileLogger, but it is not defined.")
+            ::Rails.logger.warn("Call stack: #{cs}")
+          else
+            ::Rails.logger.warn("Method #{name} called on ScoutApm::Logging::Loggers::FileLogger, but it is not defined. Try setting 'logs_method_missing_call_stack' to true in your Scout configuration to see the call stack.") # rubocop:disable Layout/LineLength
+          end
         end
 
         # More impactful for the broadcast logger.
         def respond_to_missing?(name, *_args)
           super
         end
+
+        private
+
+        # Useful for testing.
+        def filter_log_location(the_call_stack = caller_locations)
+          the_call_stack.find { |loc| loc.path.include?(Rails.root.to_s) }
+        end
+
+        # Cache call stack to reduce performance impact.
+        def call_stack
+          @call_stack ||= caller_locations(4, ScoutApm::Logging::Context.instance.config.value('logs_call_stack_search_depth'))
+        end
+
+        def find_log_location
+          filter_log_location(call_stack)
+        end
+
+        def get_call_stack_for_attribute
+          call_stack
+            .select { |loc| loc.path.include?(Rails.root.to_s) }
+            .map(&:to_s)
+            .slice(0, ScoutApm::Logging::Context.instance.config.value('logs_call_stack_capture_depth'))
+            .join("\n")
+        end
+
+        # Ideally, we would pass an additional argument to the formatter, but
+        # we run into issues with how tagged logging is implemented. As such,
+        # this is a work around for tagged logging and incorrect passed arguments.
+        # May need to move to fiber at some point.
+        def format_message(severity, datetime, progname, msg)
+          if ScoutApm::Logging::Context.instance.config.value('logs_capture_call_stack')
+            Thread.current[:scout_log_location] =
+              get_call_stack_for_attribute
+          end
+
+          super(severity, datetime, progname, msg)
+
+        # Reset for next logger call.
+        ensure
+          @call_stack = nil
+          Thread.current[:scout_log_location] = nil
+        end
+
+        def add_log_file_and_line_to_message(message)
+          return message unless message.is_a?(String)
+
+          file = find_log_location
+          return message unless file
+
+          file_path = file.path.split('/').last
+          line_number = file.lineno
+
+          "[#{file_path}:#{line_number}] #{message}"
+        end
       end
 
       # The newly created logger which we can configure, and will log to a filepath.

data/lib/scout_apm/logging/loggers/opentelemetry/log_record_data_compat.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module OpenTelemetry
+  module SDK
+    module Logs
+      # The OTLP logs exporter and the logs SDK are versioned independently, and every exporter
+      # release only requires `opentelemetry-logs-sdk ~> 0.1`, so Bundler can resolve pairs that
+      # disagree on LogRecordData's fields:
+      #   * exporter <= 0.5.1 reads `total_recorded_attributes`, which logs-sdk >= 0.7.0 replaced
+      #     with `dropped_attributes_count` (read by exporter >= 0.6.0). See #114.
+      #   * exporter >= 0.5.0 reads `event_name`, which logs-sdk < 0.6.0 does not have.
+      # Define whichever of these is missing so any resolved pair can export.
+      class LogRecordData
+        unless method_defined?(:total_recorded_attributes)
+          def total_recorded_attributes
+            attributes&.size.to_i + dropped_attributes_count.to_i
+          end
+        end
+
+        unless method_defined?(:dropped_attributes_count)
+          def dropped_attributes_count
+            [total_recorded_attributes.to_i - attributes&.size.to_i, 0].max
+          end
+        end
+
+        unless method_defined?(:event_name)
+          def event_name
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/logging/loggers/opentelemetry/opentelemetry.rb

@@ -4,7 +4,7 @@ require 'opentelemetry'
 require 'opentelemetry/sdk'
 require 'opentelemetry-logs-sdk'
 require 'opentelemetry/exporter/otlp_logs'
-require_relative './log_record_patch'
+require_relative './log_record_data_compat'
 
 module ScoutApm
   module Logging

data/lib/scout_apm/logging/version.rb

@@ -2,6 +2,6 @@
 
 module ScoutApm
   module Logging
-    VERSION = '2.0.0'
+    VERSION = '2.2.0'
   end
 end

data/lib/scout_apm_logging.rb

@@ -15,9 +15,7 @@ module ScoutApm
       # If we are in a Rails environment, setup the monitor daemon manager.
       class RailTie < ::Rails::Railtie
         initializer 'scout_apm_logging.monitor', after: :initialize_logger, before: :initialize_cache do
-          context = Context.new
-          context.config = Config.with_file(context, context.config.value('config_file'))
-          context.config.log_settings(context.logger)
+          context = ScoutApm::Logging::Context.instance
 
           Loggers::Capture.new(context).setup!
         end

data/scout_apm_logging.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'opentelemetry-common'
   s.add_dependency 'opentelemetry-exporter-otlp-logs', '>= 0.2.0'
   s.add_dependency 'opentelemetry-instrumentation-base'
+  s.add_dependency 'opentelemetry-logs-api'
   s.add_dependency 'opentelemetry-logs-sdk', '>= 0.2.0'
   s.add_dependency 'opentelemetry-sdk', '>= 1.2'
   s.add_dependency 'scout_apm'
@@ -31,4 +32,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rubocop', '1.50.2'
   s.add_development_dependency 'rubocop-ast', '1.30.0'
   s.add_development_dependency 'webmock'
+  # Old, but works. It is a small wrapper library around websocket-eventmachine
+  # for ActionCable protocols.
+  s.add_development_dependency 'action_cable_client'
 end

data/spec/integration/rails/lifecycle_spec.rb

@@ -1,10 +1,20 @@
 require 'webmock/rspec'
 
+# Old, but still works.
+require 'action_cable_client'
+require 'eventmachine'
 require 'spec_helper'
 require 'zlib'
 require 'stringio'
+require 'securerandom'
 require_relative '../../rails/app'
 
+ScoutApm::Logging::Loggers::FileLogger.class_exec do
+  define_method(:filter_log_location) do |locations|
+    locations.find { |loc| loc.path.include?(Rails.root.to_s) && !loc.path.include?('scout_apm/logging') }
+  end
+end
+
 describe ScoutApm::Logging do
   before do
     @file_path = '/app/response_body.txt'
@@ -14,8 +24,8 @@ describe ScoutApm::Logging do
         # We have to write to the file, as we are applying the patch in the fork, and
         # need to run the expectations in the main process.
         File.open(@file_path, 'a+') do |file|
-          msgs = transform_body_to_msgs(request.body)
-          file.puts(msgs)
+          records = transform_body_to_records(request.body)
+          records.each { |record| file.puts(record.to_json) }
         end
         { body: '', headers: {}, status: 200 }
       end
@@ -38,6 +48,27 @@ describe ScoutApm::Logging do
     # Call the app to generate the logs
     `curl localhost:9292`
 
+    channel_client = fork do
+      url = 'ws://localhost:9292/cable'
+      channel_name = 'TestChannel'
+      # Loops.
+      EventMachine.run do
+        client = ActionCableClient.new(url, channel_name)
+        # called whenever a welcome message is received from the server
+        client.connected { puts 'successfully connected.' }
+
+        client.subscribed do
+          puts 'client subscribed to the channel.'
+          client.perform('ding', { message: 'hello from client' })
+        end
+
+        # called whenever a message is received from the server
+        client.received do |message|
+          puts message
+        end
+      end
+    end
+
     sleep 5
 
     proxy_dir = context.config.value('logs_proxy_log_dir')
@@ -55,32 +86,52 @@ describe ScoutApm::Logging do
     end
 
     local_messages = lines.map { |item| item['msg'] }
+    puts local_messages
 
     # Verify we have all the logs in the local log file
     expect(local_messages.count('[TEST] Some log')).to eq(1)
     expect(local_messages.count('[YIELD] Yield Test')).to eq(1)
     expect(local_messages.count('Another Log')).to eq(1)
     expect(local_messages.count('Should not be captured')).to eq(0)
-
-    log_locations = lines.map { |item| item['log_location'] }.compact
-
-    # Verify that log attributes aren't persisted
-    expect(log_locations.size).to eq(1)
+    expect(local_messages.count('Warn level log')).to eq(1)
+    expect(local_messages.count('Error level log')).to eq(1)
+    expect(local_messages.count('Fatal level log')).to eq(1)
 
     # Verify the logs are sent to the receiver
-    receiver_contents = File.readlines(@file_path, chomp: true)
-    expect(receiver_contents.count('[TEST] Some log')).to eq(1)
-    expect(receiver_contents.count('[YIELD] Yield Test')).to eq(1)
-    expect(receiver_contents.count('Another Log')).to eq(1)
-    expect(receiver_contents.count('Should not be captured')).to eq(0)
+    receiver_records = File.readlines(@file_path, chomp: true).map { |line| JSON.parse(line) }
+    receiver_messages = receiver_records.map { |record| record['body'] }
+    expect(receiver_messages.count('[TEST] Some log')).to eq(1)
+    expect(receiver_messages.count('[YIELD] Yield Test')).to eq(1)
+    expect(receiver_messages.count('Another Log')).to eq(1)
+    expect(receiver_messages.count('Should not be captured')).to eq(0)
+    expect(receiver_messages.count('Warn level log')).to eq(1)
+    expect(receiver_messages.count('Error level log')).to eq(1)
+    expect(receiver_messages.count('Fatal level log')).to eq(1)
+
+    # Verify the severity number sent on the wire uses the OpenTelemetry scale,
+    # not Ruby's Logger::Severity scale. Guards against upstream exporter drift
+    # now that the severity-remapping patch has been removed.
+    expect(severity_for(receiver_records, 'Warn level log')).to eq(:SEVERITY_NUMBER_WARN)
+    expect(severity_for(receiver_records, 'Error level log')).to eq(:SEVERITY_NUMBER_ERROR)
+    expect(severity_for(receiver_records, 'Fatal level log')).to eq(:SEVERITY_NUMBER_FATAL)
+    expect(severity_for(receiver_records, '[TEST] Some log')).to eq(:SEVERITY_NUMBER_INFO)
+
+    # Verify we recorded server ActionCable messages
+    expect(receiver_messages.count { |msg| msg.include?('ActionCable Connected:') }).to eq(1)
+    expect(receiver_messages.count('Subscribed to test_channel')).to eq(1)
+    expect(receiver_messages.count { |msg| msg.include?('Ding received with data: {"message"') }).to eq(1)
+    expect(local_messages.count { |msg| msg.include?('ActionCable Connected:') }).to eq(1)
+    expect(local_messages.count('Subscribed to test_channel')).to eq(1)
+    expect(local_messages.count { |msg| msg.include?('Ding received with data: {"message"') }).to eq(1)
 
     # Kill the rails process. We use kill as using any other signal throws a long log line.
     Process.kill('KILL', rails_pid)
+    Process.kill('KILL', channel_client)
   end
 
   private
 
-  def transform_body_to_msgs(body)
+  def transform_body_to_records(body) # rubocop:disable Metrics/AbcSize
     gz = Zlib::GzipReader.new(StringIO.new(body))
     uncompressed = gz.read
 
@@ -90,9 +141,18 @@ describe ScoutApm::Logging do
     value_hash[:resource_logs].map do |item|
       item[:scope_logs].map do |sl|
         sl[:log_records].map do |log|
-          log[:body][:string_value]
+          {
+            'body' => log[:body][:string_value],
+            'severity_number' => log[:severity_number],
+            'severity_text' => log[:severity_text]
+          }
         end
       end
     end.flatten
   end
+
+  def severity_for(records, body)
+    record = records.find { |item| item['body'] == body }
+    record && record['severity_number']&.to_sym
+  end
 end

data/spec/rails/app.rb

@@ -5,6 +5,7 @@ rescue LoadError # rubocop:disable Lint/SuppressedException
 end
 
 require 'action_controller/railtie'
+require 'action_cable/engine'
 require 'logger'
 require 'scout_apm_logging'
 
@@ -13,24 +14,58 @@ Rails.logger = ActiveSupport::TaggedLogging.new(Logger.new($stdout))
 class App < ::Rails::Application
   config.eager_load = false
   config.log_level = :info
+  config.action_cable.cable = { 'adapter' => 'async' }
+  config.action_cable.connection_class = -> { ApplicationCable::Connection }
+  config.action_cable.disable_request_forgery_protection = true
 
   routes.append do
+    mount ActionCable.server => '/cable'
     root to: 'root#index'
   end
 end
 
 class RootController < ActionController::Base
-  def index
-    Rails.logger.warn('Add location log attributes')
+  def index # rubocop:disable Metrics/AbcSize
     Rails.logger.tagged('TEST').info('Some log')
     Rails.logger.tagged('YIELD') { logger.info('Yield Test') }
     Rails.logger.info('Another Log')
     Rails.logger.debug('Should not be captured')
+    Rails.logger.warn('Warn level log')
+    Rails.logger.error('Error level log')
+    Rails.logger.fatal('Fatal level log')
 
     render plain: Rails.version
   end
 end
 
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end
+
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    identified_by :id
+
+    def connect
+      self.id = SecureRandom.uuid
+      logger.info("ActionCable Connected: #{id}")
+    end
+  end
+end
+
+class TestChannel < ApplicationCable::Channel
+  def subscribed
+    stream_from 'test_channel'
+    logger.info 'Subscribed to test_channel'
+  end
+
+  def ding(data)
+    logger.info "Ding received with data: #{data.inspect}"
+    transmit({ dong: "Server response to: '#{data['message']}'" })
+  end
+end
+
 def initialize_app
   App.initialize!
 

data/spec/unit/loggers/formatter_spec.rb

@@ -0,0 +1,86 @@
+require 'json'
+require 'logger'
+require 'stringio'
+
+require 'spec_helper'
+
+require 'scout_apm_logging'
+
+describe ScoutApm::Logging::Loggers::Formatter do
+  context 'severity' do
+    let(:exporter) { OpenTelemetry::SDK::Logs::Export::InMemoryLogRecordExporter.new }
+
+    before do
+      ScoutApm::Logging::Context.instance
+
+      provider = OpenTelemetry::SDK::Logs::LoggerProvider.new
+      provider.add_log_record_processor(OpenTelemetry::SDK::Logs::Export::SimpleLogRecordProcessor.new(exporter))
+      ScoutApm::Logging::Loggers::OpenTelemetry.logger_provider = provider
+    end
+
+    {
+      'DEBUG' => :SEVERITY_NUMBER_DEBUG,
+      'INFO' => :SEVERITY_NUMBER_INFO,
+      'WARN' => :SEVERITY_NUMBER_WARN,
+      'ERROR' => :SEVERITY_NUMBER_ERROR,
+      'FATAL' => :SEVERITY_NUMBER_FATAL,
+      'ANY' => :SEVERITY_NUMBER_FATAL,
+      'SOMETHING_ELSE' => :SEVERITY_NUMBER_UNSPECIFIED
+    }.each do |label, expected|
+      it "emits #{expected} for #{label}" do
+        described_class.new.call(label, Time.now, nil, 'msg')
+
+        record = exporter.emitted_log_records.last
+        expect(record.severity_text).to eq(label)
+        expect(record.severity_number).to eq(OpenTelemetry::Logs::SeverityNumber.const_get(expected))
+      end
+    end
+
+    it 'maps Logger#unknown to FATAL' do
+      logger = ::Logger.new(StringIO.new)
+      logger.formatter = described_class.new
+      logger.unknown('gone')
+
+      expect(exporter.emitted_log_records.last.severity_number).to eq(OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_FATAL)
+    end
+  end
+
+  context 'encoding' do
+    let(:formatter) { ScoutApm::Logging::Loggers::Formatter.new }
+    let(:otel_logger) { double(on_emit: nil) }
+
+    before do
+      allow(ScoutApm::Logging::Loggers::OpenTelemetry).to receive(:logger_provider).and_return(double(logger: otel_logger))
+    end
+
+    it 'should replace bytes that are not valid UTF-8' do
+      line = formatter.call('INFO', Time.now, nil, "bad \xFF byte")
+
+      expect(JSON.parse(line)['msg']).to eq("bad \u{FFFD} byte")
+    end
+
+    it 'should read binary text, as a request path is logged, as UTF-8' do
+      line = formatter.call('INFO', Time.now, nil, 'café /x?%FF'.b + "\xFF".b)
+
+      expect(JSON.parse(line)['msg']).to eq("café /x?%FF\u{FFFD}")
+    end
+
+    it 'should keep valid text in another encoding' do
+      line = formatter.call('INFO', Time.now, nil, 'café'.encode('UTF-16LE'))
+
+      expect(JSON.parse(line)['msg']).to eq('café')
+    end
+
+    it 'should replace bad bytes in an exception message' do
+      line = formatter.call('ERROR', Time.now, nil, RuntimeError.new("bad \xFF byte".b))
+
+      expect(JSON.parse(line)['msg']).to eq("bad \u{FFFD} byte (RuntimeError)\n")
+    end
+
+    it 'should emit the replaced text as the OpenTelemetry body' do
+      formatter.call('INFO', Time.now, nil, "bad \xFF byte".b)
+
+      expect(otel_logger).to have_received(:on_emit).with(hash_including(body: "bad \u{FFFD} byte"))
+    end
+  end
+end

data/spec/unit/loggers/logger_spec.rb

@@ -0,0 +1,94 @@
+require 'logger'
+require 'stringio'
+
+require 'spec_helper'
+
+require 'scout_apm_logging'
+
+def capture_stdout
+  old_stdout = $stdout
+  $stdout = StringIO.new
+  yield
+  $stdout.string
+ensure
+  $stdout = old_stdout
+end
+
+describe ScoutApm::Logging::Loggers::Logger do
+  before do
+    allow_any_instance_of(ScoutApm::Logging::Loggers::Formatter).to receive(:emit_log)
+  end
+
+  it 'should not capture call stack or log line' do
+    ScoutApm::Logging::Context.instance
+
+    output_from_log = capture_stdout do
+      logger = ScoutApm::Logging::Loggers::FileLogger.new($stdout).tap do |instance|
+        instance.level = 0
+        instance.formatter = ScoutApm::Logging::Loggers::Formatter.new
+      end
+
+      logger.info('Hi')
+    end
+
+    expect(output_from_log).not_to include('"log_location":"')
+    expect(output_from_log).not_to include('"msg":"[logger_spec.rb')
+  end
+
+  it 'should capture call stack' do
+    ENV['SCOUT_LOGS_CAPTURE_CALL_STACK'] = 'true'
+    ScoutApm::Logging::Context.instance
+
+    output_from_log = capture_stdout do
+      logger = ScoutApm::Logging::Loggers::FileLogger.new($stdout).tap do |instance|
+        instance.level = 0
+        instance.formatter = ScoutApm::Logging::Loggers::Formatter.new
+      end
+
+      logger.info('Hi')
+    end
+
+    expect(output_from_log).to include('"log_location":"')
+    expect(output_from_log).not_to include('"msg":"[logger_spec.rb')
+    ENV['SCOUT_LOGS_CAPTURE_LOG_LINE'] = 'false' # set back to default
+  end
+
+  it 'should capture log line and call stack' do
+    ENV['SCOUT_LOGS_CAPTURE_CALL_STACK'] = 'true'
+    ENV['SCOUT_LOGS_CAPTURE_LOG_LINE'] = 'true'
+
+    ScoutApm::Logging::Context.instance
+
+    output_from_log = capture_stdout do
+      logger = ScoutApm::Logging::Loggers::FileLogger.new($stdout).tap do |instance|
+        instance.level = 0
+        instance.formatter = ScoutApm::Logging::Loggers::Formatter.new
+      end
+
+      logger.info('Hi')
+    end
+
+    expect(output_from_log).to include('"msg":"[logger_spec.rb')
+    expect(output_from_log).to include('"log_location":"')
+    ENV['SCOUT_LOGS_CAPTURE_CALL_STACK'] = 'false' # set back to default
+    ENV['SCOUT_LOGS_CAPTURE_LOG_LINE'] = 'false' # set back to default
+  end
+
+  it 'should capture log line' do
+    ENV['SCOUT_LOGS_CAPTURE_LOG_LINE'] = 'true'
+    ScoutApm::Logging::Context.instance
+
+    output_from_log = capture_stdout do
+      logger = ScoutApm::Logging::Loggers::FileLogger.new($stdout).tap do |instance|
+        instance.level = 0
+        instance.formatter = ScoutApm::Logging::Loggers::Formatter.new
+      end
+
+      logger.info('Hi')
+    end
+
+    expect(output_from_log).not_to include('"log_location":"')
+    expect(output_from_log).to include('"msg":"[logger_spec.rb')
+    ENV['SCOUT_LOGS_CAPTURE_LOG_LINE'] = 'false' # set back to default
+  end
+end

data/spec/unit/loggers/opentelemetry/log_record_data_compat_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+require_relative '../../../../lib/scout_apm/logging/loggers/opentelemetry/opentelemetry'
+
+describe OpenTelemetry::SDK::Logs::LogRecordData do
+  let(:exporter) { OpenTelemetry::SDK::Logs::Export::InMemoryLogRecordExporter.new }
+
+  let(:log_record_data) do
+    provider = OpenTelemetry::SDK::Logs::LoggerProvider.new
+    provider.add_log_record_processor(OpenTelemetry::SDK::Logs::Export::SimpleLogRecordProcessor.new(exporter))
+
+    provider.logger(name: 'scout_apm', version: '0.1.0').on_emit(
+      severity_text: 'INFO',
+      severity_number: OpenTelemetry::Logs::SeverityNumber::SEVERITY_NUMBER_INFO,
+      attributes: { 'controller' => 'UsersController' },
+      timestamp: Time.now,
+      body: 'Processing by UsersController#index'
+    )
+
+    exporter.emitted_log_records.first
+  end
+
+  it 'responds to the fields read by every supported exporter version' do
+    expect(log_record_data.total_recorded_attributes).to eq(1)
+    expect(log_record_data.dropped_attributes_count).to eq(0)
+    expect(log_record_data).to respond_to(:event_name)
+  end
+
+  it 'exports through the installed OTLP exporter without raising' do
+    otlp_exporter = OpenTelemetry::Exporter::OTLP::Logs::LogsExporter.new
+    # Exporter >= 0.7.0 moved encoding into opentelemetry-exporter-otlp-common.
+    encoded = if otlp_exporter.respond_to?(:encode, true)
+                otlp_exporter.send(:encode, [log_record_data])
+              else
+                OpenTelemetry::Exporter::OTLP::Common.as_encoded_elsr([log_record_data])
+              end
+    request = Opentelemetry::Proto::Collector::Logs::V1::ExportLogsServiceRequest.decode(encoded)
+    record = request.resource_logs.first.scope_logs.first.log_records.first
+
+    expect(record.body.string_value).to eq('Processing by UsersController#index')
+    expect(record.severity_number).to eq(:SEVERITY_NUMBER_INFO)
+    expect(record.dropped_attributes_count).to eq(0)
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm_logging
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Scout APM
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: googleapis-common-protos-types
@@ -94,6 +93,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-logs-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-logs-sdk
   requirement: !ruby/object:Gem::Requirement
@@ -192,6 +205,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: action_cable_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Sets up log monitoring for Scout APM Ruby clients.
 email:
 - support@scoutapp.com
@@ -199,6 +226,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/release.yml"
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".rubocop.yml"
@@ -216,7 +244,7 @@ files:
 - lib/scout_apm/logging/loggers/formatter.rb
 - lib/scout_apm/logging/loggers/logger.rb
 - lib/scout_apm/logging/loggers/opentelemetry/NOTICE
-- lib/scout_apm/logging/loggers/opentelemetry/log_record_patch.rb
+- lib/scout_apm/logging/loggers/opentelemetry/log_record_data_compat.rb
 - lib/scout_apm/logging/loggers/opentelemetry/opentelemetry.rb
 - lib/scout_apm/logging/loggers/patches/rails_logger.rb
 - lib/scout_apm/logging/loggers/patches/tagged_logging.rb
@@ -235,11 +263,13 @@ files:
 - spec/spec_helper.rb
 - spec/unit/config_spec.rb
 - spec/unit/loggers/capture_spec.rb
+- spec/unit/loggers/formatter_spec.rb
+- spec/unit/loggers/logger_spec.rb
+- spec/unit/loggers/opentelemetry/log_record_data_compat_spec.rb
 homepage: https://github.com/scoutapp/scout_apm_ruby_logging
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -254,15 +284,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Managed log monitoring for Ruby applications.
-test_files:
-- spec/data/config_test_1.yml
-- spec/data/mock_config.yml
-- spec/integration/rails/lifecycle_spec.rb
-- spec/rails/app.rb
-- spec/spec_helper.rb
-- spec/unit/config_spec.rb
-- spec/unit/loggers/capture_spec.rb
+test_files: []

data/lib/scout_apm/logging/loggers/opentelemetry/log_record_patch.rb

@@ -1,38 +0,0 @@
-module OpenTelemetry
-  module Exporter
-    module OTLP
-      module Logs
-        # Patch the log record creation to add back severity number.
-        class LogsExporter
-          def as_otlp_log_record(log_record_data)
-            Opentelemetry::Proto::Logs::V1::LogRecord.new(
-              time_unix_nano: log_record_data.timestamp,
-              observed_time_unix_nano: log_record_data.observed_timestamp,
-              severity_number: as_otlp_severity_number(log_record_data.severity_number),
-              severity_text: log_record_data.severity_text,
-              body: as_otlp_any_value(log_record_data.body),
-              attributes: log_record_data.attributes&.map { |k, v| as_otlp_key_value(k, v) },
-              dropped_attributes_count: log_record_data.total_recorded_attributes - log_record_data.attributes&.size.to_i,
-              flags: log_record_data.trace_flags.instance_variable_get(:@flags),
-              trace_id: log_record_data.trace_id,
-              span_id: log_record_data.span_id
-            )
-          end
-
-          # TODO: This has been removed in newer versions of the OpenTelemetry Ruby Logs SDK, however
-          # it appears that we are missing the severity number. Investigate this.
-          def as_otlp_severity_number(severity_number)
-            case severity_number
-            when 0 then Opentelemetry::Proto::Logs::V1::SeverityNumber::SEVERITY_NUMBER_DEBUG
-            when 1 then Opentelemetry::Proto::Logs::V1::SeverityNumber::SEVERITY_NUMBER_INFO
-            when 2 then Opentelemetry::Proto::Logs::V1::SeverityNumber::SEVERITY_NUMBER_WARN
-            when 3 then Opentelemetry::Proto::Logs::V1::SeverityNumber::SEVERITY_NUMBER_ERROR
-            when 4 then Opentelemetry::Proto::Logs::V1::SeverityNumber::SEVERITY_NUMBER_FATAL
-            when 5 then Opentelemetry::Proto::Logs::V1::SeverityNumber::SEVERITY_NUMBER_UNSPECIFIED
-            end
-          end
-        end
-      end
-    end
-  end
-end