scout_apm_logging 0.0.12 → 1.0.0

data/lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/log_record_processor.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module ScoutApm
+  module Logging
+    module Loggers
+      module OpenTelemetry
+        module SDK
+          module Logs
+            # LogRecordProcessor describes a duck type and provides a synchronous no-op hook for when a
+            # {LogRecord} is emitted. It is not required to subclass this
+            # class to provide an implementation of LogRecordProcessor, provided the interface is
+            # satisfied.
+            class LogRecordProcessor
+              # Called when a {LogRecord} is emitted. Subsequent calls are not
+              # permitted after shutdown is called.
+              # @param [LogRecord] log_record The emitted {LogRecord}
+              # @param [Context] context The {Context}
+              def on_emit(log_record, context); end
+
+              # Export all log records to the configured `Exporter` that have not yet
+              # been exported.
+              #
+              # This method should only be called in cases where it is absolutely
+              # necessary, such as when using some FaaS providers that may suspend
+              # the process after an invocation, but before the `Processor` exports
+              # the completed spans.
+              #
+              # @param [Numeric] timeout An optional timeout in seconds.
+              # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+              #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+              def force_flush(timeout: nil)
+                Export::SUCCESS
+              end
+
+              # Called when {LoggerProvider#shutdown} is called.
+              #
+              # @param [Numeric] timeout An optional timeout in seconds.
+              # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+              #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+              def shutdown(timeout: nil)
+                Export::SUCCESS
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/logger.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module ScoutApm
+  module Logging
+    module Loggers
+      module OpenTelemetry
+        module SDK
+          module Logs
+            # The SDK implementation of OpenTelemetry::Logs::Logger
+            class Logger < OpenTelemetry::Logs::Logger
+              # @api private
+              #
+              # Returns a new {OpenTelemetry::SDK::Logs::Logger} instance. This should
+              # not be called directly. New loggers should be created using
+              # {LoggerProvider#logger}.
+              #
+              # @param [String] name Instrumentation package name
+              # @param [String] version Instrumentation package version
+              # @param [LoggerProvider] logger_provider The {LoggerProvider} that
+              #   initialized the logger
+              #
+              # @return [OpenTelemetry::SDK::Logs::Logger]
+              def initialize(name, version, logger_provider)
+                @instrumentation_scope = ::OpenTelemetry::SDK::InstrumentationScope.new(name, version)
+                @logger_provider = logger_provider
+              end
+
+              # Emit a {LogRecord} to the processing pipeline.
+              #
+              # @param [optional Time] timestamp Time when the event occurred.
+              # @param [optional Time] observed_timestamp Time when the event was
+              #   observed by the collection system.
+              # @param [optional OpenTelemetry::Trace::SpanContext] span_context The
+              #   OpenTelemetry::Trace::SpanContext to associate with the
+              #   {LogRecord}.
+              # @param severity_number [optional Integer] Numerical value of the
+              #   severity. Smaller numerical values correspond to less severe events
+              #   (such as debug events), larger numerical values correspond to more
+              #   severe events (such as errors and critical events).
+              # @param [optional String, Numeric, Boolean, Array<String, Numeric,
+              #   Boolean>, Hash{String => String, Numeric, Boolean, Array<String,
+              #   Numeric, Boolean>}] body A value containing the body of the log record.
+              # @param [optional Hash{String => String, Numeric, Boolean,
+              #   Array<String, Numeric, Boolean>}] attributes Additional information
+              #   about the event.
+              # @param [optional String (16-byte binary)] trace_id Request trace id as
+              #   defined in {https://www.w3.org/TR/trace-context/#trace-id W3C Trace Context}.
+              #   Can be set for logs that are part of request processing and have an
+              #   assigned trace id.
+              # @param [optional String (8-byte binary)] span_id Span id. Can be set
+              #   for logs that are part of a particular processing span. If span_id
+              #   is present trace_id should also be present.
+              # @param [optional Integer (8-bit byte of bit flags)] trace_flags Trace
+              #   flag as defined in {https://www.w3.org/TR/trace-context/#trace-flags W3C Trace Context}
+              #   specification. At the time of writing the specification defines one
+              #   flag - the SAMPLED flag.
+              # @param [optional OpenTelemetry::Context] context The OpenTelemetry::Context
+              #   to associate with the {LogRecord}.
+              #
+              # @api public
+              def on_emit(timestamp: nil,
+                          observed_timestamp: Time.now,
+                          severity_text: nil,
+                          severity_number: nil,
+                          body: nil,
+                          attributes: nil,
+                          trace_id: nil,
+                          span_id: nil,
+                          trace_flags: nil,
+                          context: ::OpenTelemetry::Context.current)
+
+                @logger_provider.on_emit(timestamp: timestamp,
+                                        observed_timestamp: observed_timestamp,
+                                        severity_text: severity_text,
+                                        severity_number: severity_number,
+                                        body: body,
+                                        attributes: attributes,
+                                        trace_id: nil,
+                                        span_id: nil,
+                                        trace_flags: nil,
+                                        instrumentation_scope: @instrumentation_scope,
+                                        context: context)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/logger_provider.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module ScoutApm
+  module Logging
+    module Loggers
+      module OpenTelemetry
+        module SDK
+          module Logs
+            # The SDK implementation of OpenTelemetry::Logs::LoggerProvider.
+            class LoggerProvider < OpenTelemetry::Logs::LoggerProvider
+              UNEXPECTED_ERROR_MESSAGE = 'unexpected error in ' \
+                'OpenTelemetry::SDK::Logs::LoggerProvider#%s'
+
+              private_constant :UNEXPECTED_ERROR_MESSAGE
+
+              # Returns a new LoggerProvider instance.
+              #
+              # @param [optional Resource] resource The resource to associate with
+              #   new LogRecords created by {Logger}s created by this LoggerProvider.
+              #
+              # @return [OpenTelemetry::SDK::Logs::LoggerProvider]
+              def initialize(resource: OpenTelemetry::SDK::Resources::Resource.create)
+                @log_record_processors = []
+                @mutex = Mutex.new
+                @resource = resource
+                @stopped = false
+              end
+
+              # Returns an {OpenTelemetry::SDK::Logs::Logger} instance.
+              #
+              # @param [String] name Instrumentation package name
+              # @param [optional String] version Instrumentation package version
+              #
+              # @return [OpenTelemetry::SDK::Logs::Logger]
+              def logger(name:, version: nil)
+                version ||= ''
+
+                if !name.is_a?(String) || name.empty?
+                  OpenTelemetry.logger.warn('LoggerProvider#logger called with an ' \
+                    "invalid name. Name provided: #{name.inspect}")
+                end
+
+                Logger.new(name, version, self)
+              end
+
+              # Adds a new log record processor to this LoggerProvider's
+              # log_record_processors.
+              #
+              # @param [LogRecordProcessor] log_record_processor The
+              #   {LogRecordProcessor} to add to this LoggerProvider.
+              def add_log_record_processor(log_record_processor)
+                @mutex.synchronize do
+                  if @stopped
+                    OpenTelemetry.logger.warn('calling LoggerProvider#' \
+                      'add_log_record_processor after shutdown.')
+                    return
+                  end
+                  @log_record_processors = @log_record_processors.dup.push(log_record_processor)
+                end
+              end
+
+              # Attempts to stop all the activity for this LoggerProvider. Calls
+              # {LogRecordProcessor#shutdown} for all registered {LogRecordProcessor}s.
+              #
+              # This operation may block until all log records are processed. Must
+              # be called before turning off the main application to ensure all data
+              # are processed and exported.
+              #
+              # After this is called all newly created {LogRecord}s will be no-op.
+              #
+              # @param [optional Numeric] timeout An optional timeout in seconds.
+              # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+              #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+              def shutdown(timeout: nil)
+                @mutex.synchronize do
+                  if @stopped
+                    OpenTelemetry.logger.warn('LoggerProvider#shutdown called multiple times.')
+                    return Export::FAILURE
+                  end
+
+                  start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
+                  results = @log_record_processors.map do |processor|
+                    remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
+                    break [Export::TIMEOUT] if remaining_timeout&.zero?
+
+                    processor.shutdown(timeout: remaining_timeout)
+                  end
+
+                  @stopped = true
+                  results.max || Export::SUCCESS
+                end
+              end
+
+              # Immediately export all {LogRecord}s that have not yet been exported
+              # for all the registered {LogRecordProcessor}s.
+              #
+              # This method should only be called in cases where it is absolutely
+              # necessary, such as when using some FaaS providers that may suspend
+              # the process after an invocation, but before the {LogRecordProcessor}
+              # exports the completed {LogRecord}s.
+              #
+              # @param [optional Numeric] timeout An optional timeout in seconds.
+              # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+              #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+              def force_flush(timeout: nil)
+                @mutex.synchronize do
+                  return Export::SUCCESS if @stopped
+
+                  start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
+                  results = @log_record_processors.map do |processor|
+                    remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
+                    return Export::TIMEOUT if remaining_timeout&.zero?
+
+                    processor.force_flush(timeout: remaining_timeout)
+                  end
+
+                  results.max || Export::SUCCESS
+                end
+              end
+
+              # @api private
+              def on_emit(timestamp: nil,
+                          observed_timestamp: nil,
+                          severity_text: nil,
+                          severity_number: nil,
+                          body: nil,
+                          attributes: nil,
+                          trace_id: nil,
+                          span_id: nil,
+                          trace_flags: nil,
+                          instrumentation_scope: nil,
+                          context: nil)
+
+                log_record = LogRecord.new(timestamp: timestamp,
+                                          observed_timestamp: observed_timestamp,
+                                          severity_text: severity_text,
+                                          severity_number: severity_number,
+                                          body: body,
+                                          attributes: attributes,
+                                          trace_id: trace_id,
+                                          span_id: span_id,
+                                          trace_flags: trace_flags,
+                                          resource: @resource,
+                                          instrumentation_scope: instrumentation_scope)
+
+                @log_record_processors.each { |processor| processor.on_emit(log_record, context) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/version.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module ScoutApm
+  module Logging
+    module Loggers
+      module OpenTelemetry
+        module SDK
+          module Logs
+            # Current OpenTelemetry logs sdk version
+            VERSION = '0.1.0'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require_relative 'logs/version'
+require_relative 'logs/logger'
+require_relative 'logs/logger_provider'
+require_relative 'logs/log_record'
+require_relative 'logs/log_record_data'
+require_relative 'logs/log_record_processor'
+require_relative 'logs/export'
+
+module ScoutApm
+  module Logging
+    module Loggers
+      module OpenTelemetry
+        module SDK
+          # The Logs module contains the OpenTelemetry logs reference
+          # implementation.
+          module Logs
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# A patch to Rails to allow swapping out the logger for the held logger in the proxy.
+module Rails
+  class << self
+    def logger=(new_logger)
+      @logger.tap do |rails_logger|
+        if rails_logger.respond_to?(:is_scout_proxy_logger?)
+          old_logger = rails_logger.instance_variable_get(:@loggers).first
+          rails_logger.swap_scout_loggers!(old_logger, new_logger)
+        else
+          @logger = new_logger
+        end
+      end
+    end
+  end
+end

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

@@ -4,9 +4,7 @@ module ScoutApm
   module Logging
     module Loggers
       # Holds both the original application logger and the new one. Relays commands to both.
-      class Proxy < BasicObject
-        include ::Kernel
-
+      class Proxy
         def self.create_with_loggers(*loggers)
           new.tap do |proxy_logger|
             loggers.each { |logger| proxy_logger.add_scout_loggers(logger) }
@@ -21,12 +19,19 @@ module ScoutApm
           @loggers << logger
         end
 
-        def remove_scout_loggers(logger)
+        def remove_scout_loggers!(logger)
           @loggers.reject! { |inst_log| inst_log == logger }
 
           @loggers
         end
 
+        def swap_scout_loggers!(old_logger, new_logger)
+          logger_index = @loggers.index(old_logger)
+          return unless logger_index
+
+          @loggers[logger_index] = new_logger
+        end
+
         # We don't want other libraries to change the formatter of the logger we create.
         def formatter=(formatter)
           @loggers.first.formatter = formatter
@@ -38,8 +43,20 @@ module ScoutApm
           @loggers.first.level = level
         end
 
+        def is_a?(klass)
+          @loggers.first.is_a?(klass)
+        end
+
+        def kind_of?(klass)
+          @loggers.first.is_a?(klass)
+        end
+
+        def instance_of?(klass)
+          @loggers.first.instance_of?(klass)
+        end
+
         def class
-          ::Logger
+          @loggers.first.class
         end
 
         def is_scout_proxy_logger?

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

@@ -19,8 +19,10 @@ module ScoutApm
           def update_logger!
             # 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)
+              context.logger.debug('Rails Broadcast logger detected. Adding new logger to broadcast.')
               add_logger_to_broadcast!
             else
+              context.logger.debug("Swapping in Proxy for current Rails logger: #{log_instance.class}.")
               swap_in_proxy_logger!
             end
 
@@ -37,18 +39,8 @@ module ScoutApm
             @new_file_logger ||= Loggers::Logger.new(context, log_instance).create_logger!
           end
 
-          # Eseentially creates the original logger.
-          def original_logger # rubocop:disable Metrics/AbcSize
-            # 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)
-
-            ::Logger.new(original_logdevice).tap do |logger|
-              logger.level = log_instance.level
-              logger.formatter = log_instance.formatter
-
+          def original_logger
+            @original_logger = log_instance.clone.tap do |logger|
               if ::Rails.env.development? && $stdout.tty? && $stderr.tty?
                 next if ::ActiveSupport::Logger.respond_to?(:logger_outputs_to?) && ::ActiveSupport::Logger.logger_outputs_to?(
                   logger, $stdout, $stderr

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

@@ -17,6 +17,7 @@ module ScoutApm
           end
 
           def update_logger!
+            context.logger.debug('Swapping in Proxy for Test logger.')
             swap_in_proxy_logger!
 
             new_log_location
@@ -34,16 +35,7 @@ module ScoutApm
 
           # Eseentially creates the original logger.
           def original_logger
-            # 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)
-
-            ::Logger.new(original_logdevice).tap do |logger|
-              logger.level = log_instance.level
-              logger.formatter = log_instance.formatter
-            end
+            @original_logger = log_instance.clone
           end
 
           def new_log_location

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

@@ -17,6 +17,7 @@ module ScoutApm
           end
 
           def update_logger!
+            context.logger.debug("Swapping in Proxy for current Sidekiq logger: #{log_instance.class}.")
             swap_in_proxy_logger!
 
             new_log_location
@@ -38,12 +39,7 @@ module ScoutApm
             # 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)
-
-            ::Logger.new(original_logdevice).tap do |logger|
-              logger.level = log_instance.level
-              logger.formatter = log_instance.formatter
-            end
+            @original_logger = log_instance.clone
           end
 
           def new_log_location

data/lib/scout_apm/logging/utils.rb

@@ -12,75 +12,6 @@ module ScoutApm
 
         FileUtils.mkdir_p(file_path) unless File.directory?(file_path)
       end
-
-      # TODO: Add support for other platforms
-      def self.get_architecture
-        if /arm/ =~ RbConfig::CONFIG['arch']
-          'arm64'
-        else
-          'amd64'
-        end
-      end
-
-      def self.get_host_os
-        if /darwin|mac os/ =~ RbConfig::CONFIG['host_os']
-          'darwin'
-        else
-          'linux'
-        end
-      end
-
-      def self.check_process_liveliness(pid, name)
-        # Pipe to cat to prevent truncation of the output
-        process_information = `ps -p #{pid} -o pid=,stat=,command= | cat`
-        return false if process_information.empty?
-
-        process_information_parts = process_information.split(' ')
-        process_information_status = process_information_parts[1]
-
-        return false if process_information_status == 'Z'
-        return false unless process_information.include?(name)
-
-        true
-      end
-
-      def self.current_process_is_app_server?
-        # TODO: Add more app servers.
-        process_command = `ps -p #{Process.pid} -o command= | cat`.downcase
-        [
-          process_command.include?('puma'),
-          process_command.include?('unicorn'),
-          process_command.include?('passenger')
-        ].any?
-      end
-
-      def self.skip_setup?
-        [
-          ARGV.include?('assets:precompile'),
-          ARGV.include?('assets:clean'),
-          (defined?(::Rails::Console) && $stdout.isatty && $stdin.isatty)
-        ].any?
-      end
-
-      def self.attempt_exclusive_lock(context)
-        lock_file = context.config.value('manager_lock_file')
-        ensure_directory_exists(lock_file)
-
-        begin
-          file = File.open(lock_file, File::RDWR | File::CREAT | File::EXCL)
-        rescue Errno::EEXIST
-          context.logger.info('Manager lock file held, continuing.')
-          return
-        end
-
-        # Ensure the lock file is deleted when the block completes
-        begin
-          yield
-        ensure
-          file.close
-          File.delete(lock_file) if File.exist?(lock_file)
-        end
-      end
     end
   end
 end

data/lib/scout_apm/logging/version.rb

@@ -2,6 +2,6 @@
 
 module ScoutApm
   module Logging
-    VERSION = '0.0.12'
+    VERSION = '1.0.0'
   end
 end

data/lib/scout_apm_logging.rb

@@ -6,28 +6,19 @@ require 'scout_apm/logging/config'
 require 'scout_apm/logging/logger'
 require 'scout_apm/logging/context'
 require 'scout_apm/logging/utils'
-require 'scout_apm/logging/state'
-
 require 'scout_apm/logging/loggers/capture'
 
-require 'scout_apm/logging/monitor_manager/manager'
-
 module ScoutApm
   ## This module is responsible for setting up monitoring of the application's logs.
   module Logging
     if defined?(Rails) && defined?(Rails::Railtie)
       # If we are in a Rails environment, setup the monitor daemon manager.
       class RailTie < ::Rails::Railtie
-        initializer 'scout_apm_logging.monitor' do
-          context = ScoutApm::Logging::MonitorManager.instance.context
+        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'))
 
           Loggers::Capture.new(context).setup!
-
-          unless Utils.skip_setup?
-            Utils.attempt_exclusive_lock(context) do
-              ScoutApm::Logging::MonitorManager.instance.setup!
-            end
-          end
         end
       end
     end

data/scout_apm_logging.gemspec

@@ -17,9 +17,16 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 2.6'
 
+  s.add_dependency 'googleapis-common-protos-types'
+  s.add_dependency 'google-protobuf', '< 3.18'
+  s.add_dependency 'opentelemetry-api'
+  s.add_dependency 'opentelemetry-common'
+  s.add_dependency 'opentelemetry-instrumentation-base'
+  s.add_dependency 'opentelemetry-sdk', '>= 1.2'
   s.add_dependency 'scout_apm'
 
   s.add_development_dependency 'rspec'
   s.add_development_dependency 'rubocop', '1.50.2'
   s.add_development_dependency 'rubocop-ast', '1.30.0'
+  s.add_development_dependency 'webmock'
 end

data/spec/data/config_test_1.yml

@@ -9,7 +9,6 @@ common: &defaults
   ###
   logs_monitor: true
   logs_ingest_key: "00001000010000abc"
-  logs_monitored: ["/tmp/fake_log_file.log"]
 
 production:
   <<: *defaults

data/spec/data/mock_config.yml

@@ -9,9 +9,6 @@ common: &defaults
   ###
   logs_monitor: true
   logs_ingest_key: "00001000010000abc"
-  logs_monitored: ["/tmp/fake_log_file.log"]
-  # Need to give a high enough number for the original health check to pass
-  monitor_interval: 10
 
 production:
   <<: *defaults