scout_apm_logging 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7064d80f9892529f81a77b0e46f9e517e8ea96f8e9e53880ee2eefd6c5abbf2
-  data.tar.gz: 3a3ec083c05435e99d23b719bbc31f38d7ce4a07ddcf25ef47fed544147ea21c
+  metadata.gz: 3a472edfe7271717a5eb8b5c76f1dda7a84dc1b8ad2f0da4c6223173f87c44db
+  data.tar.gz: 1eaf6f5de049078460287b0b02e09583cad2db3fc31c3b54a7d83930d5fca787
 SHA512:
-  metadata.gz: d7ea291371355544a94b69d3ab7ad75ee7407c84d450bb3e9a44ce6aabfa6bb2c27ce5813276111fb6584268eaba59875d346bd6b36b83c4db0d153478f7ba9f
-  data.tar.gz: ff9ee96494248654b146c2cc9d45cc7db960196781661cc94e3f79ebbabde83930b4c264e67c0270cd24e1510027242b62e307cda061b26e1b2789d1af5f7941
+  metadata.gz: f74a53847327e6068ad671b8f2363516971b6ee04f9aea1f2c47d5ea069eae3ba70ea5b36be17c3bd57e2d378cd3c3835c6a229d1ea825793c8456585630c4a1
+  data.tar.gz: b3de4ed980c0129c615574b6e55e1bb245df9f85d515a3dba0fad8ebc2fe692cd99c9aeff2b96a47b4efb24fbe34fbbc540d78fcc96a048b25fab84ef6363b29

data/.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
     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

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 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/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

@@ -12,24 +12,31 @@ 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
+        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
 
+        def emit_log(msg, severity, time, attributes_to_log)
           ScoutApm::Logging::Loggers::OpenTelemetry.logger_provider.logger(
             name: 'scout_apm',
             version: '0.1.0'
@@ -41,11 +48,8 @@ module ScoutApm
             body: msg,
             context: ::OpenTelemetry::Context.current
           )
-          message
         end
 
-        private
-
         def format_datetime(time)
           time.utc.strftime(DATETIME_FORMAT)
         end
@@ -103,15 +107,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/version.rb

@@ -2,6 +2,6 @@
 
 module ScoutApm
   module Logging
-    VERSION = '2.0.0'
+    VERSION = '2.1.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

@@ -31,4 +31,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'
@@ -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,17 +86,16 @@ 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)
@@ -73,9 +103,21 @@ 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

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/logger_spec.rb

@@ -0,0 +1,95 @@
+require 'logger'
+require 'stringio'
+
+require 'spec_helper'
+
+require 'scout_apm_logging'
+
+ScoutApm::Logging::Loggers::Formatter.class_exec do
+  define_method(:emit_log) do |msg, severity, time, attributes_to_log|
+  end
+end
+
+def capture_stdout
+  old_stdout = $stdout
+  $stdout = StringIO.new
+  yield
+  $stdout.string
+ensure
+  $stdout = old_stdout
+end
+
+describe ScoutApm::Logging::Loggers::Logger do
+  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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm_logging
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Scout APM
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-28 00:00:00.000000000 Z
+date: 2025-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: googleapis-common-protos-types
@@ -192,6 +192,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
@@ -235,6 +249,7 @@ files:
 - spec/spec_helper.rb
 - spec/unit/config_spec.rb
 - spec/unit/loggers/capture_spec.rb
+- spec/unit/loggers/logger_spec.rb
 homepage: https://github.com/scoutapp/scout_apm_ruby_logging
 licenses:
 - MIT
@@ -266,3 +281,4 @@ test_files:
 - spec/spec_helper.rb
 - spec/unit/config_spec.rb
 - spec/unit/loggers/capture_spec.rb
+- spec/unit/loggers/logger_spec.rb