scout_apm_logging 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83a18019240ac4086ab5fbbc2c729c334123830425a569442629783bb0e20a65
-  data.tar.gz: 9f4e105cf2d85cc9352434c7749fc61bbc3545ee2b5baee56c86a0f0a47b14a8
+  metadata.gz: c7064d80f9892529f81a77b0e46f9e517e8ea96f8e9e53880ee2eefd6c5abbf2
+  data.tar.gz: 3a3ec083c05435e99d23b719bbc31f38d7ce4a07ddcf25ef47fed544147ea21c
 SHA512:
-  metadata.gz: 426922ace12c94d8e84c9840971884b55ca9ac2328c15f76553f3259987448ea264bed665b85fb3bfa34d14230a556ababd1b7810fa339174c31bc851210a33d
-  data.tar.gz: 72503cc9faaf7130028e466f71ea785ec3ece65a82cc5a88d318e68f4123ba89464961a9a6c50c2e22061b0c39cdce0d8af045b4e0c3577e2f4b86709ae527d7
+  metadata.gz: d7ea291371355544a94b69d3ab7ad75ee7407c84d450bb3e9a44ce6aabfa6bb2c27ce5813276111fb6584268eaba59875d346bd6b36b83c4db0d153478f7ba9f
+  data.tar.gz: ff9ee96494248654b146c2cc9d45cc7db960196781661cc94e3f79ebbabde83930b4c264e67c0270cd24e1510027242b62e307cda061b26e1b2789d1af5f7941

data/.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
     env:
       DOCKER_RUBY_VERSION: ${{ matrix.ruby }}
       BUNDLE_GEMFILE: gems/rails.gemfile
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-20.04
     steps:
       - uses: actions/checkout@v2
       - name: Extract Library Version

data/.rubocop.yml

@@ -8,11 +8,10 @@ AllCops:
     - "gems/*"
     - "Rakefile"
   NewCops: disable
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.1
 
 Metrics/BlockLength:
   Exclude:
-    - "scout_apm_logging.gemspec"
     - "spec/**/*"
 
 Metrics/ClassLength:

data/CHANGELOG.md

@@ -1,14 +1,8 @@
-## 1.2.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.
+* Breaking: Drop support for Ruby 2.6, 2.7, 3.0. 
+  * Note: The 1.x release is still maintained.
 
 ## 1.1.0
 * Bump vendored SDK version to 0.2.0.

data/README.md

@@ -2,7 +2,7 @@
 
 [![Build Status](https://github.com/scoutapp/scout_apm_ruby_logging/actions/workflows/test.yml/badge.svg)](https://github.com/scoutapp/scout_apm_ruby_logging/actions)
 
-A Ruby gem for detailed, easy to navigate, managed log monitoring.
+A Ruby gem for detailed, easy to navigate, managed log monitoring. Supports Ruby 2.6+.
 
 Sign up for an account at https://www.scoutapm.com to start monitoring your logs and application performance in minutes.
 
@@ -32,6 +32,11 @@ Update your [RAILS_ROOT/config/scout_apm.yml](https://scoutapm.com/apps/new_ruby
 
 Deploy :rocket:
 
+## 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.
+
+The `main` branch contains the 2.x version, while the `1.x` branch contains the 1.x version.
+
 ## Testing
 To run the entire test suite:
 ```ruby
@@ -45,7 +50,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.3 bundle exec rake test
+DOCKER_RUBY_VERSION=3.4 bundle exec rake test
 ```
 
 ## Local

data/lib/scout_apm/logging/config.rb

@@ -19,12 +19,19 @@
 # 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
-# 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
+# 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
 #
 # Any of these config settings can be set with an environment variable prefixed
 # by SCOUT_ and uppercasing the key: SCOUT_LOG_LEVEL for instance.
@@ -48,23 +55,11 @@ 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_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
+        'logs_log_file_size' => IntegerCoercion.new
       }.freeze
 
       # The bootstrapped, and initial config that we attach to the context. Will be swapped out by
@@ -109,7 +104,7 @@ module ScoutApm
       def all_settings
         KNOWN_CONFIG_OPTIONS.inject([]) do |memo, key|
           o = overlay_for_key(key)
-          memo << { key: key, value: value(key).inspect, source: o.name }
+          memo << { key:, value: value(key).inspect, source: o.name }
         end
       end
 
@@ -122,13 +117,7 @@ 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_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
+          'logs_log_file_size' => 1024 * 1024 * 10
         }.freeze
 
         def value(key)

data/lib/scout_apm/logging/context.rb

@@ -7,14 +7,6 @@ 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

@@ -12,31 +12,24 @@ module ScoutApm
       class Formatter < ::Logger::Formatter
         DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S.%LZ'
 
-        def call(severity, time, progname, msg)
+        def call(severity, time, progname, msg) # rubocop:disable Metrics/AbcSize
           attributes_to_log = {
-            severity: severity,
+            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
 
-          emit_log(msg, severity, time, attributes_to_log)
-
-          "#{attributes_to_log.to_json}\n"
-        end
-
-        private
+          message = "#{attributes_to_log.to_json}\n"
 
-        def emit_log(msg, severity, time, attributes_to_log)
           ScoutApm::Logging::Loggers::OpenTelemetry.logger_provider.logger(
             name: 'scout_apm',
             version: '0.1.0'
@@ -48,8 +41,11 @@ module ScoutApm
             body: msg,
             context: ::OpenTelemetry::Context.current
           )
+          message
         end
 
+        private
+
         def format_datetime(time)
           time.utc.strftime(DATETIME_FORMAT)
         end
@@ -107,6 +103,15 @@ 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,70 +7,6 @@ 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
@@ -78,75 +14,13 @@ module ScoutApm
         def method_missing(name, *_args)
           return unless defined?(::Rails)
 
-          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
+          ::Rails.logger.warn("Method #{name} called on ScoutApm::Logging::Loggers::FileLogger, but it is not defined.")
         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_patch.rb

@@ -0,0 +1,38 @@
+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

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

@@ -2,37 +2,15 @@
 require 'logger'
 require 'opentelemetry'
 require 'opentelemetry/sdk'
-
-require_relative 'api/logs'
-require_relative 'sdk/logs'
-require_relative 'exporter/exporter/otlp/version'
-require_relative 'exporter/exporter/otlp/logs_exporter'
+require 'opentelemetry-logs-sdk'
+require 'opentelemetry/exporter/otlp_logs'
+require_relative './log_record_patch'
 
 module ScoutApm
   module Logging
     module Loggers
       module OpenTelemetry
         class << self
-          # Overwritten on setup to be the internal logger.
-          # @return [Object, Logger] configured Logger or a default STDOUT Logger.
-          def logger
-            @logger ||= ::Logger.new($stdout, level: ENV['OTEL_LOG_LEVEL'] || ::Logger::INFO)
-          end
-
-          # @return [Callable] configured error handler or a default that logs the
-          #   exception and message at ERROR level.
-          def error_handler
-            @error_handler ||= ->(exception: nil, message: nil) { logger.error("OpenTelemetry error: #{[message, exception&.message, exception&.backtrace&.first].compact.join(' - ')}") }
-          end
-
-          # Handles an error by calling the configured error_handler.
-          #
-          # @param [optional Exception] exception The exception to be handled
-          # @param [optional String] message An error message.
-          def handle_error(exception: nil, message: nil)
-            error_handler.call(exception: exception, message: message)
-          end
-
           def logger_provider=(logger_provider)
             @logger_provider = logger_provider
           end
@@ -43,12 +21,11 @@ module ScoutApm
         end
 
         def self.setup(context)
-          @logger = context.logger
-
-          exporter = OpenTelemetry::Exporter::OTLP::LogsExporter.new(endpoint: context.config.value('logs_reporting_endpoint_http'))
-          processor = OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(exporter)
-          ScoutApm::Logging::Loggers::OpenTelemetry.logger_provider = OpenTelemetry::SDK::Logs::LoggerProvider.new(resource: scout_resource(context))
-          ScoutApm::Logging::Loggers::OpenTelemetry.logger_provider.add_log_record_processor(processor)
+          exporter = ::OpenTelemetry::Exporter::OTLP::Logs::LogsExporter.new(endpoint: context.config.value('logs_reporting_endpoint_http'))
+          processor = ::OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(exporter)
+          OpenTelemetry.logger_provider = ::OpenTelemetry::SDK::Logs::LoggerProvider.new(resource: scout_resource(context))
+          OpenTelemetry.logger_provider.add_log_record_processor(processor)
+          ::OpenTelemetry.logger = context.logger || ::Logger.new($stdout, level: ENV['OTEL_LOG_LEVEL'] || ::Logger::INFO)
         end
 
         def self.scout_resource(context)

data/lib/scout_apm/logging/version.rb

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

data/lib/scout_apm_logging.rb

@@ -15,7 +15,9 @@ 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 = ScoutApm::Logging::Context.instance
+          context = Context.new
+          context.config = Config.with_file(context, context.config.value('config_file'))
+          context.config.log_settings(context.logger)
 
           Loggers::Capture.new(context).setup!
         end

data/scout_apm_logging.gemspec

@@ -15,13 +15,15 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.require_paths = ['lib']
 
-  s.required_ruby_version = '>= 2.6'
+  s.required_ruby_version = '>= 3.1'
 
   s.add_dependency 'googleapis-common-protos-types'
-  s.add_dependency 'google-protobuf', '~> 3.0'
+  s.add_dependency 'google-protobuf', '>= 3.18'
   s.add_dependency 'opentelemetry-api'
   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-sdk', '>= 0.2.0'
   s.add_dependency 'opentelemetry-sdk', '>= 1.2'
   s.add_dependency 'scout_apm'
 
@@ -29,7 +31,4 @@ 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,20 +1,10 @@
 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'
@@ -48,27 +38,6 @@ 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')
@@ -85,19 +54,18 @@ describe ScoutApm::Logging do
       end
     end
 
-    puts lines
-
     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)
-    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)
+
+    log_locations = lines.map { |item| item['log_location'] }.compact
+
+    # Verify that log attributes aren't persisted
+    expect(log_locations.size).to eq(1)
 
     # Verify the logs are sent to the receiver
     receiver_contents = File.readlines(@file_path, chomp: true)
@@ -105,21 +73,9 @@ describe ScoutApm::Logging do
     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)
-    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 we recorded server ActionCable messages
-    expect(receiver_contents.count { |msg| msg.include?('ActionCable Connected:') }).to eq(1)
-    expect(receiver_contents.count('Subscribed to test_channel')).to eq(1)
-    expect(receiver_contents.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
@@ -128,7 +84,7 @@ describe ScoutApm::Logging do
     gz = Zlib::GzipReader.new(StringIO.new(body))
     uncompressed = gz.read
 
-    value = ScoutApm::Logging::Loggers::Opentelemetry::Proto::Collector::Logs::V1::ExportLogsServiceRequest.decode(uncompressed)
+    value = ::Opentelemetry::Proto::Collector::Logs::V1::ExportLogsServiceRequest.decode(uncompressed)
     value_hash = value.to_h
 
     value_hash[:resource_logs].map do |item|