scout_apm_logging 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbe47505a0defc4e795ece37c30380707600c95708954f2aa99b86e2eff5aefb
-  data.tar.gz: 7aa1c9af19eb96358fbc5ceb037b901cc2dd4a01ab87cc6d737f9b0205fa77cf
+  metadata.gz: 7a99a84cd9f8dd023b8717c81e5d80b17c99f5afb8c7e7edb6152193ef7fecdf
+  data.tar.gz: b9d2e44b40adcb5f9acc13f6ef6d2176e79ed6b056f6e6d1e8f9f0359857ebf6
 SHA512:
-  metadata.gz: a1d8ee77dd245e14a26a40298c5c77d61af4b1869aa4bc8d53ae1856ae336456148a7a3d2ad865b1e920ef4184fe14120cb07dc453e7b6a8e25738495123a7f1
-  data.tar.gz: 25380fc37e48a7a6a6f901246faf3fec03884c4665a853d6decb3646a566a8b637aaf1851e86f76865429838fb631aaa5d0c245dd9ff7d453824f80a854f2ce3
+  metadata.gz: 1f73329ada6fde049cf1ffe18ad2d43c0fa09158cffcc10e51c58f897d9cd40f1aa2636ee645e2b26d7a36204e082ca318c5281e8e32759aaac2b685a4ff5f32
+  data.tar.gz: 664471524c4802ad23cfeee6299a56259d07e7a9a9d2fb241393202b4116946052f695982ada22c3060a39fca25f351ce6a90487e329283bc264749e6ee56738

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+## 0.0.4
+* Fix memoizing of log attributes, which could lead to persistent attributes.
+
+## 0.0.3
+* **Feature**: Add support for TaggedLogging.
+* Add ability to customize file logger size. Increase default size to 10MiB.
+* Fix an issue with removing of the monitor process when Rails workers exited, which was only intended for when the main process exits.
+* Fix an issue with the known monitored logs state being removed on port flushing.

data/lib/scout_apm/logging/config.rb

@@ -54,6 +54,7 @@ module ScoutApm
         logs_config
         logs_reporting_endpoint
         logs_proxy_log_dir
+        logs_log_file_size
         manager_lock_file
         monitor_pid_file
         monitor_state_file
@@ -72,6 +73,7 @@ module ScoutApm
       SETTING_COERCIONS = {
         'logs_monitor' => BooleanCoercion.new,
         'logs_monitored' => JsonCoercion.new,
+        'logs_log_file_size' => IntegerCoercion.new,
         'monitor_interval' => IntegerCoercion.new,
         'monitor_interval_delay' => IntegerCoercion.new,
         'health_check_port' => IntegerCoercion.new
@@ -229,6 +231,7 @@ module ScoutApm
           'logs_capture_level' => 'debug',
           'logs_reporting_endpoint' => 'https://otlp.scoutotel.com:4317',
           'logs_proxy_log_dir' => '/tmp/scout_apm/logs/',
+          'logs_log_file_size' => 1024 * 1024 * 10,
           'manager_lock_file' => '/tmp/scout_apm/monitor_lock_file.lock',
           'monitor_pid_file' => '/tmp/scout_apm/scout_apm_log_monitor.pid',
           'monitor_state_file' => '/tmp/scout_apm/scout_apm_log_monitor_state.json',

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

@@ -8,6 +8,7 @@ require_relative './proxy'
 require_relative './swaps/rails'
 require_relative './swaps/sidekiq'
 require_relative './swaps/scout'
+require_relative './patches/tagged_logging'
 
 module ScoutApm
   module Logging
@@ -26,11 +27,40 @@ module ScoutApm
           @context = context
         end
 
-        def capture_and_swap_log_locations!
+        def setup!
           return unless context.config.value('logs_monitor')
 
           create_proxy_log_dir!
 
+          add_logging_patches!
+          capture_and_swap_log_locations!
+        end
+
+        private
+
+        def create_proxy_log_dir!
+          Utils.ensure_directory_exists(context.config.value('logs_proxy_log_dir'))
+        end
+
+        def add_logging_patches!
+          # We can't swap out the logger similar to that of Rails and Sidekiq, as
+          # the TaggedLogging logger is dynamically generated.
+          return unless Rails.logger.respond_to?(:tagged)
+
+          ::ActiveSupport::TaggedLogging.prepend(Patches::TaggedLogging)
+
+          # 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'))
+          return unless isruby27 && Rails.logger.respond_to?(:broadcasts)
+
+          Rails.logger.broadcasts.each do |logger|
+            logger.extend ::ActiveSupport::TaggedLogging
+          end
+        end
+
+        def capture_and_swap_log_locations!
           # We can move this to filter_map when our lagging version is Ruby 2.7
           updated_log_locations = KNOWN_LOGGERS.map do |logger|
             logger.new(context).update_logger! if logger.present?
@@ -39,12 +69,6 @@ module ScoutApm
 
           context.config.state.add_log_locations!(updated_log_locations)
         end
-
-        private
-
-        def create_proxy_log_dir!
-          Utils.ensure_directory_exists(context.config.value('logs_proxy_log_dir'))
-        end
       end
     end
   end

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

@@ -12,12 +12,15 @@ 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
-          attributes_to_log[:severity] = severity
-          attributes_to_log[:time] = format_datetime(time)
+        def call(severity, time, progname, msg)
+          attributes_to_log = {
+            severity: severity,
+            time: format_datetime(time),
+            pid: Process.pid.to_s,
+            msg: msg2str(msg)
+          }
+
           attributes_to_log[:progname] = progname if progname
-          attributes_to_log[:pid] = Process.pid.to_s
-          attributes_to_log[:msg] = msg2str(msg)
           attributes_to_log['service.name'] = service_name
 
           attributes_to_log.merge!(scout_layer)
@@ -30,10 +33,6 @@ module ScoutApm
 
         private
 
-        def attributes_to_log
-          @attributes_to_log ||= {}
-        end
-
         def format_datetime(time)
           time.utc.strftime(DATETIME_FORMAT)
         end

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

@@ -10,8 +10,6 @@ module ScoutApm
       class Logger
         attr_reader :context, :log_instance
 
-        # 1 MiB
-        LOG_SIZE = 1024 * 1024
         # 1 log file
         LOG_AGE = 1
 
@@ -21,15 +19,16 @@ module ScoutApm
         end
 
         def create_logger!
-          # Defaults are 7 files with 10 MiB.
           # We create the file in order to prevent a creation header log.
           File.new(determine_file_path, 'w+') unless File.exist?(determine_file_path)
-          new_logger = FileLogger.new(determine_file_path, LOG_AGE, LOG_SIZE)
-          # Ruby's Logger handles a lot of the coercion itself.
-          new_logger.level = context.config.value('logs_capture_level')
-          # Add our custom formatter to the logger.
-          new_logger.formatter = Formatter.new
-          new_logger
+          log_size = context.config.value('logs_log_file_size')
+
+          FileLogger.new(determine_file_path, LOG_AGE, log_size).tap do |logger|
+            # Ruby's Logger handles a lot of the coercion itself.
+            logger.level = context.config.value('logs_capture_level')
+            # Add our custom formatter to the logger.
+            logger.formatter = Formatter.new
+          end
         end
 
         def determine_file_path # rubocop:disable Metrics/AbcSize

data/lib/scout_apm/logging/loggers/patches/tagged_logging.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative '../logger'
+require_relative '../formatter'
+require_relative '../proxy'
+
+module ScoutApm
+  module Logging
+    module Loggers
+      module Patches
+        # Patches TaggedLogging to work with our loggers.
+        module TaggedLogging
+          def tagged(*tags) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            super(*tags) unless (self == ::Rails.logger && is_a?(ScoutApm::Logging::Loggers::Proxy)) ||
+                                (::Rails.logger.respond_to?(:broadcasts) && ::Rails.logger.broadcasts.include?(self))
+
+            if is_a?(ScoutApm::Logging::Loggers::Proxy)
+              if block_given?
+                # We skip the first logger to prevent double tagging when calling formatter.tagged
+                loggers = @loggers[1..]
+                pushed_counts = extend_and_push_tags(loggers, *tags)
+
+                formatter.tagged(*tags) { yield self }.tap do
+                  logger_pop_tags(loggers, pushed_counts)
+                end
+              else
+                loggers = instance_variable_get(:@loggers)
+
+                new_loggers = create_cloned_extended_loggers(loggers, nil, *tags)
+
+                self.clone.tap do |cp| # rubocop:disable Style/RedundantSelf
+                  cp.instance_variable_set(:@loggers, new_loggers)
+                end
+              end
+            elsif block_given?
+              # We skip the first logger to prevent double tagging when calling formatter.tagged
+              loggers = ::Rails.logger.broadcasts[1..]
+              pushed_counts = extend_and_push_tags(loggers, *tags)
+
+              formatter.tagged(*tags) { yield self }.tap do
+                logger_pop_tags(loggers, pushed_counts)
+              end
+            else
+              broadcasts = ::Rails.logger.broadcasts
+
+              tagged_loggers = broadcasts.select { |logger| logger.respond_to?(:tagged) }
+              file_logger = broadcasts.find { |logger| logger.is_a?(Loggers::FileLogger) }
+              loggers = tagged_loggers << file_logger
+
+              current_tags = tagged_loggers.first.formatter.current_tags
+
+              new_loggers = create_cloned_extended_loggers(loggers, current_tags, *tags)
+              Proxy.create_with_loggers(*new_loggers)
+            end
+          end
+
+          def create_cloned_extended_loggers(loggers, current_tags = nil, *tags)
+            loggers.map do |logger|
+              logger_current_tags = if current_tags
+                                      current_tags
+                                    elsif logger.formatter.respond_to?(:current_tags)
+                                      logger.formatter.current_tags
+                                    else
+                                      []
+                                    end
+
+              ::ActiveSupport::TaggedLogging.new(logger).tap do |new_logger|
+                if defined?(::ActiveSupport::TaggedLogging::LocalTagStorage)
+                  new_logger.formatter.extend ::ActiveSupport::TaggedLogging::LocalTagStorage
+                end
+                new_logger.push_tags(*logger_current_tags, *tags)
+              end
+            end
+          end
+
+          def extend_and_push_tags(loggers, *tags)
+            loggers.map do |logger|
+              logger.formatter.extend ::ActiveSupport::TaggedLogging::Formatter unless logger.formatter.respond_to?(:tagged)
+
+              logger.formatter.push_tags(tags).size
+            end
+          end
+
+          def logger_pop_tags(loggers, pushed_counts)
+            loggers.map.with_index do |logger, index|
+              logger.formatter.pop_tags(pushed_counts[index])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,10 +5,9 @@ module ScoutApm
     module Loggers
       # Holds both the original application logger and the new one. Relays commands to both.
       class Proxy
-        def self.create_with_loggers(original_logger, new_file_logger)
+        def self.create_with_loggers(*loggers)
           new.tap do |proxy_logger|
-            proxy_logger.add(original_logger)
-            proxy_logger.add(new_file_logger)
+            loggers.each { |logger| proxy_logger.add(logger) }
           end
         end
 

data/lib/scout_apm/logging/loggers/swaps/rails.rb

@@ -61,8 +61,14 @@ module ScoutApm
           def swap_in_proxy_logger!
             # First logger needs to be the original logger for the return value of relayed calls.
             proxy_logger = Proxy.create_with_loggers(original_logger, new_file_logger)
+            proxy_logger.extend ::ActiveSupport::TaggedLogging if log_instance.respond_to?(:tagged)
 
             ::Rails.logger = proxy_logger
+
+            # We also need to swap some of the Rails railtie loggers.
+            ::ActiveRecord::Base.logger = proxy_logger if defined?(::ActiveRecord::Base)
+            ::ActionController::Base.logger = proxy_logger if defined?(::ActionController::Base)
+            ::ActiveJob::Base.logger = proxy_logger if defined?(::ActiveJob::Base)
           end
         end
       end

data/lib/scout_apm/logging/monitor/monitor.rb

@@ -29,6 +29,7 @@ module ScoutApm
 
       def initialize
         @context = Context.new
+        context.logger.debug('Monitor instance created')
 
         context.application_root = $stdin.gets&.chomp
 
@@ -83,6 +84,7 @@ module ScoutApm
         exit if fork
         $stdin.reopen '/dev/null'
 
+        context.logger.debug("Monitor process daemonized, PID: #{Process.pid}")
         File.write(context.config.value('monitor_pid_file'), Process.pid)
       end
 

data/lib/scout_apm/logging/monitor_manager/manager.rb

@@ -47,10 +47,13 @@ module ScoutApm
       # treated as the same file as before.
       # If logs get rotated, the fingerprint changes, and the collector automatically detects this.
       def add_exit_handler!
+        # With the use of unicorn and puma worker killer, we want to ensure we only restart (exit and
+        # eventually start) the monitor and collector when the main process exits, and not the workers.
+        initialized_process_id = Process.pid
         at_exit do
           # Only remove/restart the monitor and collector if we are exiting from an app_server process.
           # We need to wait on this check, as the process command line changes at some point.
-          if Utils.current_process_is_app_server?
+          if Utils.current_process_is_app_server? && Process.pid == initialized_process_id
             context.logger.debug('Exiting from app server process. Removing monitor and collector processes.')
             remove_processes
           end
@@ -87,7 +90,10 @@ module ScoutApm
 
         # Naive benchmarks show this taking ~0.01 seconds.
         loop do
-          break if File.exist?(context.config.value('monitor_pid_file'))
+          if File.exist?(context.config.value('monitor_pid_file'))
+            context.logger.debug('Monitor PID file exists. Releasing lock.')
+            break
+          end
 
           if Time.now - start_time > timeout_seconds
             context.logger.warn('Unable to verify monitor PID file write. Releasing lock.')

data/lib/scout_apm/logging/state.rb

@@ -28,18 +28,16 @@ module ScoutApm
               memo[key] = context.config.value(key)
             end
 
-            unless updated_log_locations.empty?
-              contents = file.read
+            contents = file.read
+            old_log_state_files = if contents.empty?
+                                    []
+                                  else
+                                    current_data = JSON.parse(contents)
+                                    current_data['logs_monitored']
+                                  end
 
-              olds_log_files = if contents.empty?
-                                 []
-                               else
-                                 current_data = JSON.parse(contents)
-                                 current_data['logs_monitored']
-                               end
-
-              data['logs_monitored'] = merge_and_dedup_log_locations(updated_log_locations, olds_log_files)
-            end
+            data['logs_monitored'] =
+              merge_and_dedup_log_locations(updated_log_locations, old_log_state_files, data['logs_monitored'])
 
             file.rewind # Move cursor to beginning of the file
             file.truncate(0) # Truncate existing content
@@ -55,9 +53,10 @@ module ScoutApm
 
         # Should we add better detection for similar basenames but different paths?
         # May be a bit tricky with tools like capistrano and releases paths differentiated by time.
-        def merge_and_dedup_log_locations(new_logs, old_logs)
-          # Take the new logs if duplication, as we could be in a newer release.
-          merged = (new_logs + old_logs).each_with_object({}) do |log_path, hash|
+        def merge_and_dedup_log_locations(*log_locations)
+          # Take the new logs if duplication (those first passed in the args) as we could be in a newer release.
+          logs = log_locations.reduce([], :concat)
+          merged = logs.each_with_object({}) do |log_path, hash|
             base_name = File.basename(log_path)
             hash[base_name] ||= log_path
           end

data/lib/scout_apm/logging/version.rb

@@ -2,6 +2,6 @@
 
 module ScoutApm
   module Logging
-    VERSION = '0.0.2'
+    VERSION = '0.0.4'
   end
 end

data/lib/scout_apm_logging.rb

@@ -21,7 +21,7 @@ module ScoutApm
         initializer 'scout_apm_logging.monitor' do
           context = ScoutApm::Logging::MonitorManager.instance.context
 
-          Loggers::Capture.new(context).capture_and_swap_log_locations!
+          Loggers::Capture.new(context).setup!
 
           unless Utils.skip_setup?
             Utils.attempt_exclusive_lock(context) do

data/spec/integration/loggers/capture_spec.rb

@@ -62,7 +62,7 @@ describe ScoutApm::Logging::Loggers::Capture do
   def similuate_railtie
     context = ScoutApm::Logging::MonitorManager.instance.context
 
-    ScoutApm::Logging::Loggers::Capture.new(context).capture_and_swap_log_locations!
+    ScoutApm::Logging::Loggers::Capture.new(context).setup!
     ScoutApm::Logging::MonitorManager.new.setup!
   end
 end

data/spec/integration/monitor/collector/downloader/will_verify_checksum.rb

@@ -12,7 +12,9 @@ describe ScoutApm::Logging::Collector::Downloader do
 
     File.write(otelcol_contrib_path, 'fake content')
 
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time start: #{Time.now}"
     ScoutApm::Logging::MonitorManager.instance.setup!
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time after setup: #{Time.now}"
 
     # Give the process time to initialize, download the collector, and start it
     wait_for_process_with_timeout!('otelcol-contrib', 20)

data/spec/integration/monitor/collector_healthcheck_spec.rb

@@ -11,7 +11,9 @@ describe ScoutApm::Logging::Monitor do
 
     ScoutApm::Logging::Utils.ensure_directory_exists('/tmp/scout_apm/scout_apm_log_monitor.pid')
 
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time start: #{Time.now}"
     ScoutApm::Logging::MonitorManager.instance.setup!
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time after setup: #{Time.now}"
 
     # Give the process time to initialize, download the collector, and start it
     wait_for_process_with_timeout!('otelcol-contrib', 20)

data/spec/integration/monitor/continuous_state_collector_spec.rb

@@ -11,7 +11,9 @@ describe ScoutApm::Logging::Monitor do
 
     context = ScoutApm::Logging::MonitorManager.instance.context
     collector_pid_location = context.config.value('collector_pid_file')
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time start: #{Time.now}"
     ScoutApm::Logging::MonitorManager.instance.setup!
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time after setup: #{Time.now}"
     # Give the process time to initialize, download the collector, and start it
     wait_for_process_with_timeout!('otelcol-contrib', 20)
 

data/spec/integration/monitor/previous_collector_setup_spec.rb

@@ -11,7 +11,10 @@ describe ScoutApm::Logging::Monitor do
     collector_pid_location = ScoutApm::Logging::MonitorManager.instance.context.config.value('collector_pid_file')
     ScoutApm::Logging::Utils.ensure_directory_exists(monitor_pid_location)
 
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time start: #{Time.now}"
     ScoutApm::Logging::MonitorManager.instance.setup!
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time after setup: #{Time.now}"
+
     # Give the process time to initialize, download the collector, and start it
     wait_for_process_with_timeout!('otelcol-contrib', 20)
 

data/spec/integration/monitor_manager/disable_agent_spec.rb

@@ -9,7 +9,9 @@ describe ScoutApm::Logging::Collector::Manager do
 
     expect(`pgrep otelcol-contrib --runstates D,R,S`).to be_empty
 
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time start: #{Time.now}"
     ScoutApm::Logging::MonitorManager.instance.setup!
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time after setup: #{Time.now}"
 
     wait_for_process_with_timeout!('otelcol-contrib', 20)
 

data/spec/integration/monitor_manager/monitor_pid_file_spec.rb

@@ -15,7 +15,9 @@ describe ScoutApm::Logging::Collector::Manager do
       file.write('123456')
     end
 
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time start: #{Time.now}"
     ScoutApm::Logging::MonitorManager.instance.setup!
+    ScoutApm::Logging::MonitorManager.instance.context.logger.info "Time after setup: #{Time.now}"
 
     # Give the process time to initialize, download the collector, and start it
     wait_for_process_with_timeout!('otelcol-contrib', 20)

data/spec/integration/rails/lifecycle_spec.rb

@@ -1,14 +1,17 @@
 require 'spec_helper'
+require_relative '../../rails/app'
 
 describe ScoutApm::Logging do
   it 'checks the Rails lifecycle for creating the daemon and collector processes' do
     ENV['SCOUT_LOGS_MONITOR'] = 'true'
-    ENV['SCOUT_LOGS_MONITORED'] = '["/tmp/test.log"]'
 
-    pid_file = ScoutApm::Logging::MonitorManager.instance.context.config.value('monitor_pid_file')
+    context = ScoutApm::Logging::MonitorManager.instance.context
+    pid_file = context.config.value('monitor_pid_file')
     expect(File.exist?(pid_file)).to be_falsey
 
-    make_basic_app
+    rails_pid = fork do
+      initialize_app
+    end
 
     wait_for_process_with_timeout!('otelcol-contrib', 20)
 
@@ -21,6 +24,37 @@ describe ScoutApm::Logging do
     # Check if the process with the stored PID is running
     expect(ScoutApm::Logging::Utils.check_process_liveliness(pid, 'scout_apm_logging_monitor')).to be_truthy
 
+    # Call the app to generate the logs
+    `curl localhost:8080`
+
+    proxy_dir = context.config.value('logs_proxy_log_dir')
+    files = Dir.entries(proxy_dir) - ['.', '..']
+    log_file = File.join(proxy_dir, files[0])
+
+    lines = []
+    File.open(log_file, 'r') do |file|
+      file.each_line do |line|
+        # Parse each line as JSON
+        lines << JSON.parse(line)
+      rescue JSON::ParserError => e
+        puts e
+      end
+    end
+
+    messages = lines.map { |item| item['msg'] }
+
+    # Verify we have all the logs
+    expect(messages.count('[TEST] Some log')).to eq(1)
+    expect(messages.count('[YIELD] Yield Test')).to eq(1)
+    expect(messages.count('Another 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)
+
+    # Kill the rails process. We use kill as using any other signal throws a long log line.
+    Process.kill('KILL', rails_pid)
     # Kill the process and ensure PID file clean up
     Process.kill('TERM', pid)
     sleep 1 # Give the process time to exit

data/spec/rails/app.rb

@@ -0,0 +1,39 @@
+# https://github.com/rack/rack/pull/1937
+begin
+  require 'rackup'
+rescue LoadError # rubocop:disable Lint/SuppressedException
+end
+
+require 'action_controller/railtie'
+require 'logger'
+require 'scout_apm_logging'
+
+Rails.logger = ActiveSupport::TaggedLogging.new(Logger.new($stdout))
+
+class App < ::Rails::Application
+  config.eager_load = false
+
+  routes.append do
+    root to: 'root#index'
+  end
+end
+
+class RootController < ActionController::Base
+  def index
+    Rails.logger.warn('Add location log attributes')
+    Rails.logger.tagged('TEST').info('Some log')
+    Rails.logger.tagged('YIELD') { logger.info('Yield Test') }
+    Rails.logger.info('Another Log')
+    render plain: Rails.version
+  end
+end
+
+def initialize_app
+  App.initialize!
+
+  if defined?(Rack::Server)
+    Rack::Server.start(app: App)
+  else
+    Rackup::Server.start(app: App)
+  end
+end

data/spec/spec_helper.rb

@@ -21,6 +21,7 @@ class ScoutTestLogger < ::Logger
 end
 
 RSpec.configure do |config|
+  ENV["SCOUT_LOG_FILE_PATH"] = "STDOUT"
   ENV["SCOUT_LOG_LEVEL"] = "debug"
   ENV["SCOUT_COLLECTOR_LOG_LEVEL"] = "info"
 
@@ -29,30 +30,6 @@ RSpec.configure do |config|
   end
 end
 
-# Taken from:
-# https://github.com/rails/rails/blob/v7.1.3.2/railties/test/isolation/abstract_unit.rb#L252
-def make_basic_app
-  @app = Class.new(Rails::Application) do
-    def self.name; "RailtiesTestApp"; end
-  end
-  @app.config.hosts << proc { true }
-  @app.config.eager_load = false
-  @app.config.session_store :cookie_store, key: "_myapp_session"
-  @app.config.active_support.deprecation = :log
-  @app.config.log_level = :info
-  @app.config.secret_key_base = "b3c631c314c0bbca50c1b2843150fe33"
-
-  yield @app if block_given?
-  @app.initialize!
-
-  @app.routes.draw do
-    get "/" => "omg#index"
-  end
-
-  require "rack/test"
-  extend ::Rack::Test::Methods
-end
-
 def wait_for_process_with_timeout!(name, timeout_time)
   Timeout::timeout(timeout_time) do
     loop do

data/spec/unit/loggers/capture_spec.rb

@@ -29,7 +29,7 @@ describe ScoutApm::Logging::Loggers::Capture do
       TestLoggerWrapper.logger = ScoutTestLogger.new($stdout)
 
       capture = ScoutApm::Logging::Loggers::Capture.new(context)
-      capture.capture_and_swap_log_locations!
+      capture.setup!
 
       expect(TestLoggerWrapper.logger.class).to eq(ScoutApm::Logging::Loggers::Proxy)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm_logging
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Scout APM
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-23 00:00:00.000000000 Z
+date: 2024-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: scout_apm
@@ -76,6 +76,7 @@ files:
 - ".github/workflows/test.yml"
 - ".gitignore"
 - ".rubocop.yml"
+- CHANGELOG.md
 - Dockerfile
 - Gemfile
 - README.md
@@ -88,6 +89,7 @@ files:
 - lib/scout_apm/logging/loggers/capture.rb
 - lib/scout_apm/logging/loggers/formatter.rb
 - lib/scout_apm/logging/loggers/logger.rb
+- lib/scout_apm/logging/loggers/patches/tagged_logging.rb
 - lib/scout_apm/logging/loggers/proxy.rb
 - lib/scout_apm/logging/loggers/swaps/rails.rb
 - lib/scout_apm/logging/loggers/swaps/scout.rb
@@ -118,6 +120,7 @@ files:
 - spec/integration/monitor_manager/monitor_pid_file_spec.rb
 - spec/integration/monitor_manager/single_monitor_spec.rb
 - 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
@@ -162,6 +165,7 @@ test_files:
 - spec/integration/monitor_manager/monitor_pid_file_spec.rb
 - spec/integration/monitor_manager/single_monitor_spec.rb
 - 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