scout_apm_logging 1.0.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0d9d5323e07f8b2fe838a030d93123d00a5fb6e289fe7bc78d7ac0bcc2ebc79
-  data.tar.gz: e00d25c837617410f02ec4d6523fd5afdbb37efa633b3ecaf625f5929a1b960f
+  metadata.gz: 83a18019240ac4086ab5fbbc2c729c334123830425a569442629783bb0e20a65
+  data.tar.gz: 9f4e105cf2d85cc9352434c7749fc61bbc3545ee2b5baee56c86a0f0a47b14a8
 SHA512:
-  metadata.gz: 0d126cf0149770bb461251442e7cf2fdb40c536076d3d09131ad3d0df3763e10fb5ec4bb44ceb780b11851ab4c2276934b476033d77bcbb7fa8db7e89eed0339
-  data.tar.gz: 2c441b2bf745ca77aa154d44a536509de405051b8c363d9d8ccb95a6828fa77110b0bc3e196cf3044e7d0e1b837b295de855b428c64e8e6c7fa39d910fcb3d15
+  metadata.gz: 426922ace12c94d8e84c9840971884b55ca9ac2328c15f76553f3259987448ea264bed665b85fb3bfa34d14230a556ababd1b7810fa339174c31bc851210a33d
+  data.tar.gz: 72503cc9faaf7130028e466f71ea785ec3ece65a82cc5a88d318e68f4123ba89464961a9a6c50c2e22061b0c39cdce0d8af045b4e0c3577e2f4b86709ae527d7

data/.github/workflows/test.yml

@@ -8,20 +8,35 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2', '3.3' ]
+        ruby: ['2.6', '2.7', '3.0', '3.1', '3.2', '3.3', '3.4']
     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
+        run: |
+          VERSION=$(grep -oE '[0-9]+\.[0-9]+' lib/scout_apm/logging/version.rb | head -n 1 | cut -d '.' -f1)
+          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)) }}
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
       - name: Run RSpec
-        run: bundle exec rake test
+        run: |
+          if [[ "$LIBRARY_VERSION" == "1" && ("${{ matrix.ruby }}" == "3.4" ) ]]; then
+            echo "Skipping Ruby ${{ matrix.ruby }} for Library v1.x"
+            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"
+            exit 0
+          fi
+          bundle exec rake test
 
   rubocop:
     name: 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,18 @@
+## 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.
+
+## 1.1.0
+* Bump vendored SDK version to 0.2.0.
+
 ## 1.0.3
 * Add capturing of queue for background jobs.
 * Fix entrypoint name capturing for namespaced controllers.

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,40 +12,44 @@ 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: 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'
           ).on_emit(
             severity_text: severity,
             severity_number: ::Logger::Severity.const_get(severity),
-            attributes: attributes_to_log,
+            attributes: attributes_to_log.transform_keys(&:to_s),
             timestamp: time,
             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.