scout_apm_logging 0.0.0.1

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'logger'
+
+require 'scout_apm'
+
+module ScoutApm
+  module Logging
+    module Loggers
+      # A simple JSON formatter which we can add a couple attributes to.
+      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)
+          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)
+          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
+
+          "#{attributes_to_log.to_json}\n"
+        end
+
+        private
+
+        def attributes_to_log
+          @attributes_to_log ||= {}
+        end
+
+        def format_datetime(time)
+          time.utc.strftime(DATETIME_FORMAT)
+        end
+
+        def scout_layer # rubocop:disable Metrics/AbcSize
+          req = ScoutApm::RequestManager.lookup
+          layer = req.instance_variable_get('@layers').find { |lay| lay.type == 'Controller' || lay.type == 'Job' }
+
+          return {} unless layer
+
+          name, action = layer.name.split('/')
+
+          return {} unless name && action
+
+          updated_name = name.split('_').map(&:capitalize).join
+
+          derived_key = "#{layer.type.downcase}_entrypoint".to_sym
+          derived_value_of_scout_name = "#{updated_name}#{layer.type.capitalize}##{action.capitalize}"
+
+          { derived_key => derived_value_of_scout_name }
+        end
+
+        def scout_context
+          req = ScoutApm::RequestManager.lookup
+          extra_context = req.context.instance_variable_get('@extra')
+          user_context = req.context.instance_variable_get('@user')
+          # We may want to make this a configuration option in the future, as well as capturing
+          # the URI from the request annotations, but this may include PII.
+          user_context.delete(:ip)
+
+          user_context.transform_keys { |key| "user.#{key}" }.merge(extra_context)
+        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
+
+        # We may need to clean this up a bit.
+        def service_name
+          $PROGRAM_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module ScoutApm
+  module Logging
+    module Loggers
+      class FileLogger < ::Logger
+      end
+
+      # The newly created logger which we can configure, and will log to a filepath.
+      class Logger
+        attr_reader :context, :log_instance
+
+        # 1 MiB
+        LOG_SIZE = 1024 * 1024
+        # 1 log file
+        LOG_AGE = 1
+
+        def initialize(context, log_instance)
+          @context = context
+          @log_instance = log_instance
+        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')
+          new_logger
+        end
+
+        def determine_file_path # rubocop:disable Metrics/AbcSize
+          log_directory = context.config.value('logs_proxy_log_dir')
+
+          original_basename = File.basename(log_destination) if log_destination.is_a?(String)
+
+          file_basename = if original_basename
+                            original_basename
+                          elsif defined?(::ActiveSupport::Logger) && log_instance.is_a?(::ActiveSupport::Logger)
+                            'rails.log'
+                          elsif defined?(::ActiveSupport::BroadcastLogger) && log_instance.is_a?(::ActiveSupport::BroadcastLogger)
+                            'rails.log'
+                          elsif defined?(::Sidekiq::Logger) && log_instance.is_a?(::Sidekiq::Logger)
+                            'sidekiq.log'
+                          elsif defined?(::ScoutTestLogger) && log_instance.is_a?(::ScoutTestLogger)
+                            'test.log'
+                          else
+                            'mix.log'
+                          end
+
+          File.join(log_directory, file_basename)
+        end
+
+        private
+
+        def find_log_destination(logdev)
+          dev = try(logdev, :filename) || try(logdev, :dev)
+          if dev.is_a?(String)
+            dev
+          elsif dev.respond_to?(:path)
+            dev.path
+          elsif dev.respond_to?(:filename) || dev.respond_to?(:dev)
+            find_log_destination(dev)
+          else
+            dev
+          end
+        end
+
+        def log_destination
+          @log_destination ||= find_log_destination(log_instance.instance_variable_get(:@logdev))
+        end
+
+        def try(obj, method)
+          obj.respond_to?(method) ? obj.send(method) : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module ScoutApm
+  module Logging
+    module Loggers
+      # Holds both the original application logger and the new one. Relays commands to both.
+      class Proxy
+        def initialize
+          @loggers = []
+        end
+
+        def add(logger)
+          @loggers << logger
+        end
+
+        def remove(logger)
+          @loggers.reject! { |inst_log| inst_log == logger }
+
+          @loggers
+        end
+
+        def method_missing(name, *args, &block)
+          # Some libraries will do stuff like Library.logger.formatter = Rails.logger.formatter
+          # As such, we should return the first logger's (the original logger) return value.
+          return_value = @loggers.first.send(name, *args, &block)
+          @loggers[1..].each { |logger| logger.send(name, *args, &block) }
+
+          return_value
+        end
+
+        def respond_to_missing?(name, *args)
+          @loggers.first.respond_to?(name, *args) || super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+require_relative './formatter'
+require_relative './logger'
+
+module ScoutApm
+  module Logging
+    module Loggers
+      # Swaps in our logger for the application's logger.
+      class Swap
+        attr_reader :context, :log_instance, :new_file_logger
+
+        def initialize(context, log_instance)
+          @context = context
+          @log_instance = log_instance
+        end
+
+        def update_logger!
+          create_proxy_log_dir!
+
+          # In Rails 7.1, broadcast logger was added which allows sinking to multiple IO devices.
+          if defined?(::ActiveSupport::BroadcastLogger) && log_instance.is_a?(::ActiveSupport::BroadcastLogger)
+            add_logger_to_broadcast!
+          else
+            swap_in_proxy_logger!
+          end
+        end
+
+        def log_location
+          new_file_logger.instance_variable_get(:@logdev).filename
+        end
+
+        private
+
+        def add_logger_to_broadcast!
+          @new_file_logger = create_file_logger
+          @new_file_logger.formatter = Loggers::Formatter.new
+
+          log_instance.broadcast_to(new_file_logger)
+        end
+
+        def swap_in_proxy_logger! # rubocop:disable Metrics/AbcSize
+          proxy_logger = Proxy.new
+          # We can use the previous logdev. log_device will continuously call write
+          # through the devices until the logdev (@dev) is an IO device other than logdev:
+          # https://github.com/ruby/ruby/blob/master/lib/logger/log_device.rb#L42
+          # Log device holds the configurations around shifting too.
+          original_logdevice = log_instance.instance_variable_get(:@logdev)
+          updated_original_logger = ::Logger.new(original_logdevice)
+          updated_original_logger.formatter = log_instance.formatter
+
+          @new_file_logger = create_file_logger
+          @new_file_logger.formatter = Loggers::Formatter.new
+
+          # First logger needs to be the original logger for the return value of relayed calls.
+          proxy_logger.add(updated_original_logger)
+          proxy_logger.add(new_file_logger)
+
+          if defined?(::ActiveSupport::Logger) && log_instance.is_a?(::ActiveSupport::Logger)
+            Rails.logger = proxy_logger
+          elsif defined?(::Sidekiq::Logger) && log_instance.is_a?(::Sidekiq::Logger)
+            Sidekiq.configure_server do |config|
+              config.logger = proxy_logger
+            end
+          elsif defined?(::ScoutTestLogger) && log_instance.is_a?(::ScoutTestLogger)
+            TestLoggerWrapper.logger = proxy_logger
+          end
+        end
+
+        def create_file_logger
+          Loggers::Logger.new(context, log_instance).create_logger!
+        end
+
+        def create_proxy_log_dir!
+          Utils.ensure_directory_exists(context.config.value('logs_proxy_log_dir'))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ScoutApm
+  module Logging
+    module Collector
+      # Contains logic around verifying the checksum of the otelcol-contrib binary.
+      class Checksum
+        attr_reader :context
+
+        KNOWN_CHECKSUMS = {
+          'darwin_amd64' => '5456734e124221e7ff775c52bd3693d05b3fac43ebe06b22aa5f220f1962ed8c',
+          'darwin_arm64' => 'f9564560798ac5c099885903f303fcda97b7ea649ec299e075b72f3805873879',
+          'linux_amd64' => '326772622016f7ff7e966a7ae8a0f439dc49a3d80b6d79a82b62608af447e851',
+          'linux_arm64' => '73d797817540363a37f27e32270f98053ed17b1df36df2d30db1715ce40f4cff'
+        }.freeze
+
+        def initialize(context)
+          @context = context
+        end
+
+        def verified_checksum?(should_log_failures: false)
+          return false unless File.exist?(collector_tar_path)
+
+          checksum = `sha256sum #{collector_tar_path}`.split(' ').first
+          same_checksum_result = checksum == KNOWN_CHECKSUMS[double]
+
+          log_failed_checksum if !same_checksum_result && should_log_failures
+          same_checksum_result
+        end
+
+        def log_failed_checksum
+          if KNOWN_CHECKSUMS.key?(double)
+            context.logger.error('Checksum verification failed for otelcol.tar.gz.')
+          else
+            context.logger.error("Checksum verification failed for otelcol.tar.gz. Unknown architecture: #{double}")
+          end
+        end
+
+        private
+
+        def double
+          "#{Utils.get_host_os}_#{Utils.get_architecture}"
+        end
+
+        def collector_tar_path
+          "#{context.config.value('collector_download_dir')}/otelcol.tar.gz"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module ScoutApm
+  module Logging
+    module Collector
+      # Adds a method to Hash similar to that of the Rails deep_merge.
+      module HashDeepMerge
+        refine Hash do
+          def deep_merge(second)
+            merger = proc { |_, v1, v2|
+              if v1.is_a?(Hash) && v2.is_a?(Hash)
+                v1.merge(v2, &merger)
+              elsif v1.is_a?(Array) && v2.is_a?(Array)
+                v1 | v2
+              else
+                [:undefined, nil, :nil].include?(v2) ? v1 : v2
+              end
+            }
+            merge(second.to_h, &merger)
+          end
+        end
+      end
+
+      # Creates the configuration to be used when launching the collector.
+      class Configuration
+        using HashDeepMerge
+
+        attr_reader :context
+
+        def initialize(context)
+          @context = context
+        end
+
+        def setup!
+          create_storage_directories
+
+          create_config_file
+        end
+
+        def create_config_file
+          contents = YAML.dump(combined_contents)
+          File.write(config_file, contents)
+        end
+
+        private
+
+        def create_storage_directories
+          # Sending queue storage directory
+          Utils.ensure_directory_exists(context.config.value('collector_sending_queue_storage_dir'))
+          # Offset storage directory
+          Utils.ensure_directory_exists(context.config.value('collector_offset_storage_dir'))
+        end
+
+        def combined_contents
+          default_contents = YAML.safe_load(config_contents)
+
+          default_contents.deep_merge(loaded_config_contents)
+        end
+
+        def loaded_config_contents
+          config_path = context.config.value('logs_config')
+
+          if config_path && File.exist?(config_path)
+            YAML.load_file(config_path) || {}
+          elsif File.exist?(assumed_config_file_path)
+            YAML.load_file(assumed_config_file_path) || {}
+          else
+            {}
+          end
+        end
+
+        def config_file
+          context.config.value('collector_config_file')
+        end
+
+        def config_contents # rubocop:disable Metrics/AbcSize
+          <<~CONFIG
+            receivers:
+              filelog:
+                include: [#{context.config.value('logs_monitored').join(',')}]
+                storage: file_storage/filelogreceiver
+                operators:
+                  - type: json_parser
+                    severity:
+                      parse_from: attributes.severity
+                    timestamp:
+                      parse_from: attributes.time
+                      layout: "%Y-%m-%dT%H:%M:%S.%LZ"
+            processors:
+              transform:
+                log_statements:
+                  - context: log
+                    statements:
+                    # Copy original body to raw_bytes attribute.
+                    - 'set(attributes["raw_bytes"], body)'
+                    # Replace the body with the log message.
+                    - 'set(body, attributes["msg"])'
+                    # Move service.name attribute to resource attribute.
+                    - 'set(resource.attributes["service.name"], attributes["service.name"])'
+              batch:
+            exporters:
+              otlp:
+                endpoint: #{context.config.value('logs_reporting_endpoint')}
+                headers:
+                  x-telemetryhub-key: #{context.config.value('logs_ingest_key')}
+                sending_queue:
+                  storage: file_storage/otc
+            extensions:
+              health_check:
+                endpoint: #{health_check_endpoint}
+              file_storage/filelogreceiver:
+                directory: #{context.config.value('collector_offset_storage_dir')}
+              file_storage/otc:
+                directory: #{context.config.value('collector_sending_queue_storage_dir')}
+                timeout: 10s
+            service:
+              extensions:
+                - health_check
+                - file_storage/filelogreceiver
+                - file_storage/otc
+              pipelines:
+                logs:
+                  receivers:
+                    - filelog
+                  processors:
+                    - transform
+                    - batch
+                  exporters:
+                    - otlp
+              telemetry:
+                metrics:
+                  level: none
+                logs:
+                  level: #{context.config.value('collector_log_level')}
+          CONFIG
+        end
+
+        def health_check_endpoint
+          "localhost:#{context.config.value('health_check_port')}"
+        end
+
+        def assumed_config_file_path
+          "#{context.application_root}/config/scout_logs_config.yml"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module ScoutApm
+  module Logging
+    module Collector
+      # Downloads the collector-contrib binary from the OpenTelemetry project.
+      class Downloader
+        attr_accessor :failed_count
+        attr_reader :context, :checksum
+
+        def initialize(context)
+          @context = context
+          @checksum = Checksum.new(context)
+        end
+
+        def download!
+          # Already downloaded the collector. Noop.
+          return if checksum.verified_checksum?
+
+          # Account for issues such as failed extractions or download corruptions.
+          download_collector
+          verify_checksum
+        rescue StandardError => e
+          # Bypass Rubcop useless asignment rule.
+          failed_count ||= 0
+
+          if failed_count < 3
+            context.logger.error("Failed to download or extract otelcol-contrib: #{e}. Retrying...")
+            failed_count += 1
+            retry
+          end
+        end
+
+        def download_collector(url = nil, redirect: false) # rubocop:disable Metrics/AbcSize
+          # Prevent double logging.
+          unless redirect
+            context.logger.debug("Downloading otelcol-contrib for version #{context.config.value('collector_version')}")
+          end
+
+          url_to_download = url || collector_url
+          uri = URI(url_to_download)
+
+          Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            request = Net::HTTP::Get.new(uri)
+            http.request(request) do |response|
+              return download_collector(response['location'], redirect: true) if response.code == '302'
+
+              File.open(destination, 'wb') do |file|
+                response.read_body do |chunk|
+                  file.write(chunk)
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        def verify_checksum
+          raise 'Invalid checksum on download.' unless checksum.verified_checksum?
+        end
+
+        def collector_url
+          collector_version = context.config.value('collector_version')
+          architecture = Utils.get_architecture
+          host_os = Utils.get_host_os
+
+          # https://opentelemetry.io/docs/collector/installation/#manual-linux-installation
+          "https://github.com/open-telemetry/opentelemetry-collector-releases/releases/download/v#{collector_version}/otelcol-contrib_#{collector_version}_#{host_os}_#{architecture}.tar.gz"
+        end
+
+        def destination
+          "#{context.config.value('collector_download_dir')}/otelcol.tar.gz"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ScoutApm
+  module Logging
+    module Collector
+      # Extracts the contents of the collector tar file.
+      class Extractor
+        attr_reader :context
+
+        def initialize(context)
+          @context = context
+        end
+
+        def extract!
+          # Already extracted. Noop.
+          return if has_been_extracted?
+
+          system("tar -xzf #{tar_path} -C #{context.config.value('collector_download_dir')}")
+        end
+
+        def has_been_extracted?
+          File.exist?(binary_path)
+        end
+
+        private
+
+        def tar_path
+          "#{context.config.value('collector_download_dir')}/otelcol.tar.gz"
+        end
+
+        def binary_path
+          "#{context.config.value('collector_download_dir')}/otelcol-contrib"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative './checksum'
+require_relative './configuration'
+require_relative './downloader'
+require_relative './extractor'
+
+module ScoutApm
+  module Logging
+    module Collector
+      # Manager class for the downloading, configuring, and starting of the collector.
+      class Manager
+        attr_reader :context
+
+        def initialize(context)
+          @context = context
+
+          @checksum = Checksum.new(@context)
+          @configuration = Configuration.new(@context)
+          @downloader = Downloader.new(@context)
+          @extractor = Extractor.new(@context)
+        end
+
+        def setup!
+          @configuration.setup!
+          @downloader.download!
+          @extractor.extract!
+
+          start_collector if verified_checksum_and_extracted?
+        end
+
+        def start_collector
+          context.logger.info('Starting otelcol-contrib')
+          collector_process = Process.spawn("#{extracted_collector_path}/otelcol-contrib --config #{config_file}")
+          File.write(context.config.value('collector_pid_file'), collector_process)
+        end
+
+        private
+
+        def verified_checksum_and_extracted?
+          has_verfied_checksum = @checksum.verified_checksum?(should_log_failures: true)
+          has_extracted_content = @extractor.has_been_extracted?
+
+          has_verfied_checksum && has_extracted_content
+        end
+
+        def extracted_collector_path
+          context.config.value('collector_download_dir')
+        end
+
+        def config_file
+          context.config.value('collector_config_file')
+        end
+      end
+    end
+  end
+end