scout_apm_logging 0.0.13 → 1.0.1

data/lib/scout_apm/logging/loggers/opentelemetry/exporter/proto/resource/v1/resource_pb.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: opentelemetry/proto/resource/v1/resource.proto
+
+require 'google/protobuf'
+
+require_relative '../../common/v1/common_pb'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("scout/opentelemetry/proto/resource/v1/resource.proto", :syntax => :proto3) do
+    add_message "scout_apm.logging.loggers.opentelemetry.proto.resource.v1.Resource" do
+      repeated :attributes, :message, 1, "scout_apm.logging.loggers.opentelemetry.proto.common.v1.KeyValue"
+      optional :dropped_attributes_count, :uint32, 2
+    end
+  end
+end
+
+module ScoutApm
+  module Logging
+    module Loggers
+      module Opentelemetry
+        module Proto
+          module Resource
+            module V1
+              Resource = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("scout_apm.logging.loggers.opentelemetry.proto.resource.v1.Resource").msgclass
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+require 'logger'
+require 'opentelemetry'
+require 'opentelemetry/sdk'
+
+require_relative 'api/logs'
+require_relative 'sdk/logs'
+require_relative 'exporter/exporter/otlp/version'
+require_relative 'exporter/exporter/otlp/logs_exporter'
+
+module ScoutApm
+  module Logging
+    module Loggers
+      module OpenTelemetry
+        class << self
+          # Overwritten on setup to be the internal logger.
+          # @return [Object, Logger] configured Logger or a default STDOUT Logger.
+          def logger
+            @logger ||= ::Logger.new($stdout, level: ENV['OTEL_LOG_LEVEL'] || ::Logger::INFO)
+          end
+
+          # @return [Callable] configured error handler or a default that logs the
+          #   exception and message at ERROR level.
+          def error_handler
+            @error_handler ||= ->(exception: nil, message: nil) { logger.error("OpenTelemetry error: #{[message, exception&.message, exception&.backtrace&.first].compact.join(' - ')}") }
+          end
+
+          # Handles an error by calling the configured error_handler.
+          #
+          # @param [optional Exception] exception The exception to be handled
+          # @param [optional String] message An error message.
+          def handle_error(exception: nil, message: nil)
+            error_handler.call(exception: exception, message: message)
+          end
+
+          def logger_provider=(logger_provider)
+            @logger_provider = logger_provider
+          end
+
+          def logger_provider
+            @logger_provider
+          end
+        end
+
+        def self.setup(context)
+          @logger = context.logger
+
+          exporter = OpenTelemetry::Exporter::OTLP::LogsExporter.new(endpoint: context.config.value('logs_reporting_endpoint_http'))
+          processor = OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(exporter)
+          ScoutApm::Logging::Loggers::OpenTelemetry.logger_provider = OpenTelemetry::SDK::Logs::LoggerProvider.new(resource: scout_resource(context))
+          ScoutApm::Logging::Loggers::OpenTelemetry.logger_provider.add_log_record_processor(processor)
+        end
+
+        def self.scout_resource(context)
+          our_resources = ::OpenTelemetry::SDK::Resources::Resource.create({'telemetryhub.key' => context.config.value('logs_ingest_key')})
+          default_resources = ::OpenTelemetry::SDK::Resources::Resource.default
+          default_resources.merge(our_resources)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+# 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
+            module Export
+              # WARNING - The spec has some differences from the LogRecord version of this processor
+              # Implementation of the duck type LogRecordProcessor that batches
+              # log records exported by the SDK then pushes them to the exporter
+              # pipeline.
+              #
+              # Typically, the BatchLogRecordProcessor will be more suitable for
+              # production environments than the SimpleLogRecordProcessor.
+              class BatchLogRecordProcessor < LogRecordProcessor # rubocop:disable Metrics/ClassLength
+                # Returns a new instance of the {BatchLogRecordProcessor}.
+                #
+                # @param [LogRecordExporter] exporter The (duck type) LogRecordExporter to where the
+                #   recorded LogRecords are pushed after batching.
+                # @param [Numeric] exporter_timeout The maximum allowed time to export data.
+                #   Defaults to the value of the OTEL_BLRP_EXPORT_TIMEOUT
+                #   environment variable, if set, or 30,000 (30 seconds).
+                # @param [Numeric] schedule_delay the delay interval between two consecutive exports.
+                #   Defaults to the value of the OTEL_BLRP_SCHEDULE_DELAY environment
+                #   variable, if set, or 1,000 (1 second).
+                # @param [Integer] max_queue_size the maximum queue size in log records.
+                #   Defaults to the value of the OTEL_BLRP_MAX_QUEUE_SIZE environment
+                #   variable, if set, or 2048.
+                # @param [Integer] max_export_batch_size the maximum batch size in log records.
+                #   Defaults to the value of the OTEL_BLRP_MAX_EXPORT_BATCH_SIZE environment
+                #   variable, if set, or 512.
+                #
+                # @return a new instance of the {BatchLogRecordProcessor}.
+                def initialize(exporter,
+                              exporter_timeout: Float(ENV.fetch('OTEL_BLRP_EXPORT_TIMEOUT', 30_000)),
+                              schedule_delay: Float(ENV.fetch('OTEL_BLRP_SCHEDULE_DELAY', 1000)),
+                              max_queue_size: Integer(ENV.fetch('OTEL_BLRP_MAX_QUEUE_SIZE', 2048)),
+                              max_export_batch_size: Integer(ENV.fetch('OTEL_BLRP_MAX_EXPORT_BATCH_SIZE', 256)),
+                              start_thread_on_boot: String(ENV['OTEL_RUBY_BLRP_START_THREAD_ON_BOOT']) !~ /false/i)
+
+                  unless max_export_batch_size <= max_queue_size
+                    raise ArgumentError,
+                          'max_export_batch_size much be less than or equal to max_queue_size'
+                  end
+
+                  unless ::OpenTelemetry::Common::Utilities.valid_exporter?(exporter)
+                    raise ArgumentError,
+                          "exporter #{exporter.inspect} does not appear to be a valid exporter"
+                  end
+
+                  @exporter = exporter
+                  @exporter_timeout_seconds = exporter_timeout / 1000.0
+                  @mutex = Mutex.new
+                  @export_mutex = Mutex.new
+                  @condition = ConditionVariable.new
+                  @keep_running = true
+                  @stopped = false
+                  @delay_seconds = schedule_delay / 1000.0
+                  @max_queue_size = max_queue_size
+                  @batch_size = max_export_batch_size
+                  @log_records = []
+                  @pid = nil
+                  @thread = nil
+                  reset_on_fork(restart_thread: start_thread_on_boot)
+                end
+
+                # Adds a log record to the batch. Thread-safe; may block on lock.
+                def on_emit(log_record, _context)
+                  return if @stopped
+
+                  lock do
+                    reset_on_fork
+                    n = log_records.size + 1 - max_queue_size
+                    if n.positive?
+                      log_records.shift(n)
+                      report_dropped_log_records(n, reason: 'buffer-full')
+                    end
+                    log_records << log_record
+                    @condition.signal if log_records.size > batch_size
+                  end
+                end
+
+                # Export all emitted log records that have not yet been exported to
+                # the configured `Exporter`.
+                #
+                # 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 log records.
+                #
+                # @param [optional Numeric] timeout An optional timeout in seconds.
+                # @return [Integer] SUCCESS if no error occurred, FAILURE if a
+                #   non-specific failure occurred, TIMEOUT if a timeout occurred.
+                def force_flush(timeout: nil)
+                  start_time = ::OpenTelemetry::Common::Utilities.timeout_timestamp
+
+                  snapshot = lock do
+                    reset_on_fork if @keep_running
+                    log_records.shift(log_records.size)
+                  end
+
+                  until snapshot.empty?
+                    remaining_timeout = ::OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
+                    return TIMEOUT if remaining_timeout&.zero?
+
+                    batch = snapshot.shift(batch_size).map!(&:to_log_record_data)
+                    result_code = export_batch(batch, timeout: remaining_timeout)
+                    return result_code unless result_code == SUCCESS
+                  end
+
+                  @exporter.force_flush(timeout: ::OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
+                ensure
+                  # Unshift the remaining log records if we timed out. We drop excess
+                  # log records from the snapshot because they're older than any
+                  # records in the buffer.
+                  lock do
+                    n = log_records.size + snapshot.size - max_queue_size
+
+                    if n.positive?
+                      snapshot.shift(n)
+                      report_dropped_log_records(n, reason: 'buffer-full')
+                    end
+
+                    log_records.unshift(*snapshot) unless snapshot.empty?
+                    @condition.signal if log_records.size > max_queue_size / 2
+                  end
+                end
+
+                # Shuts the consumer thread down and flushes the current accumulated
+                # buffer will block until the thread is finished.
+                #
+                # @param [optional Numeric] timeout An optional timeout in seconds.
+                # @return [Integer] SUCCESS if no error occurred, FAILURE if a
+                #   non-specific failure occurred, TIMEOUT if a timeout occurred.
+                def shutdown(timeout: nil)
+                  return if @stopped
+
+                  start_time = ::OpenTelemetry::Common::Utilities.timeout_timestamp
+                  thread = lock do
+                    @keep_running = false
+                    @stopped = true
+                    @condition.signal
+                    @thread
+                  end
+
+                  thread&.join(timeout)
+                  force_flush(timeout: ::OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
+                  dropped_log_records = lock { log_records.size }
+                  report_dropped_log_records(dropped_log_records, reason: 'terminating') if dropped_log_records.positive?
+
+                  @exporter.shutdown(timeout: ::OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
+                end
+
+                private
+
+                attr_reader :log_records, :max_queue_size, :batch_size
+
+                def work
+                  loop do
+                    batch = lock do
+                      @condition.wait(@mutex, @delay_seconds) if log_records.size < batch_size && @keep_running
+                      @condition.wait(@mutex, @delay_seconds) while log_records.empty? && @keep_running
+                      return unless @keep_running
+
+                      fetch_batch
+                    end
+
+                    export_batch(batch)
+                  end
+                end
+
+                def reset_on_fork(restart_thread: true)
+                  pid = Process.pid
+                  return if @pid == pid
+
+                  @pid = pid
+                  log_records.clear
+                  @thread = restart_thread ? Thread.new { work } : nil
+                rescue ThreadError => e
+                  OpenTelemetry.handle_error(exception: e, message: 'unexpected error in BatchLogRecordProcessor#reset_on_fork')
+                end
+
+                def export_batch(batch, timeout: @exporter_timeout_seconds)
+                  result_code = @export_mutex.synchronize { @exporter.export(batch, timeout: timeout) }
+                  report_result(result_code, batch)
+                  result_code
+                rescue StandardError => e
+                  report_result(FAILURE, batch)
+                  OpenTelemetry.handle_error(exception: e, message: 'unexpected error in BatchLogRecordProcessor#export_batch')
+                end
+
+                def report_result(result_code, batch)
+                  if result_code == SUCCESS
+                    OpenTelemetry.logger.debug("Successfully exported #{batch.size} log records")
+                  else
+                    OpenTelemetry.handle_error(exception: ExportError.new("Unable to export #{batch.size} log records"))
+                    OpenTelemetry.logger.error("Result code: #{result_code}")
+                  end
+                end
+
+                def report_dropped_log_records(count, reason:)
+                  OpenTelemetry.logger.warn("#{count} log record(s) dropped. Reason: #{reason}")
+                end
+
+                def fetch_batch
+                  log_records.shift(@batch_size).map!(&:to_log_record_data)
+                end
+
+                def lock(&block)
+                  @mutex.synchronize(&block)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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
+            module Export
+              # LogRecordExporter describes a duck type. It is not required to
+              # subclass this class to provide an implementation of LogRecordExporter,
+              # provided the interface is satisfied. LogRecordExporter allows
+              # different tracing services to export log record data in their own format.
+              #
+              # To export data an exporter MUST be registered to the {LoggerProvider}
+              # using a {LogRecordProcessor} implementation.
+              class LogRecordExporter
+                def initialize
+                  @stopped = false
+                end
+
+                # Called to export {LogRecordData}s.
+                #
+                # @param [Enumerable<LogRecordData>] log_record_data the list of
+                # {LogRecordData} to be exported.
+                # @param [optional Numeric] timeout An optional timeout in seconds.
+                #
+                # @return [Integer] the result of the export.
+                def export(log_record_data, timeout: nil)
+                  return SUCCESS unless @stopped
+
+                  FAILURE
+                end
+
+                # Called when {LoggerProvider#force_flush} is called, if this exporter is
+                # registered to a {LoggerProvider} object.
+                #
+                # @param [optional Numeric] timeout An optional timeout in seconds.
+                # @return [Integer] SUCCESS if no error occurred, FAILURE if a
+                #   non-specific failure occurred, TIMEOUT if a timeout occurred.
+                def force_flush(timeout: nil)
+                  SUCCESS
+                end
+
+                # Called when {LoggerProvider#shutdown} is called, if this exporter is
+                # registered to a {LoggerProvider} object.
+                #
+                # @param [optional Numeric] timeout An optional timeout in seconds.
+                def shutdown(timeout: nil)
+                  @stopped = true
+                  SUCCESS
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# 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 Export module contains the built-in exporters and log record
+            # processors for the OpenTelemetry reference implementation.
+            module Export
+              ExportError = Class.new(::OpenTelemetry::Error)
+              # The operation finished successfully.
+              SUCCESS = 0
+
+              # The operation finished with an error.
+              FAILURE = 1
+
+              # The operation timed out.
+              TIMEOUT = 2
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'export/log_record_exporter'
+require_relative 'export/batch_log_record_processor'

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

@@ -0,0 +1,115 @@
+# 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
+            # Implementation of OpenTelemetry::Logs::LogRecord that records log events.
+            class LogRecord < OpenTelemetry::Logs::LogRecord
+              attr_accessor :timestamp,
+                            :observed_timestamp,
+                            :severity_text,
+                            :severity_number,
+                            :body,
+                            :attributes,
+                            :trace_id,
+                            :span_id,
+                            :trace_flags,
+                            :resource,
+                            :instrumentation_scope
+
+              # Creates a new {LogRecord}.
+              #
+              # @param [optional Time] timestamp Time when the event occurred.
+              # @param [optional Time] observed_timestamp Time when the event
+              #   was observed by the collection system. If nil, will first attempt
+              #   to set to `timestamp`. If `timestamp` is nil, will set to Time.now.
+              # @param [optional OpenTelemetry::Trace::SpanContext] span_context The
+              #   OpenTelemetry::Trace::SpanContext to associate with the LogRecord.
+              # @param [optional String] severity_text The log severity, also known as
+              #   log level.
+              # @param [optional Integer] severity_number The numerical value of the
+              #   log severity.
+              # @param [optional String, Numeric, Boolean, Array<String, Numeric,
+              #   Boolean>, Hash{String => String, Numeric, Boolean, Array<String,
+              #   Numeric, Boolean>}] body The body of the {LogRecord}.
+              # @param [optional Hash{String => String, Numeric, Boolean,
+              #   Array<String, Numeric, Boolean>}] attributes Attributes to associate
+              #   with the {LogRecord}.
+              # @param [optional String] trace_id The trace ID associated with the
+              #   current context.
+              # @param [optional String] span_id The span ID associated with the
+              #   current context.
+              # @param [optional OpenTelemetry::Trace::TraceFlags] trace_flags The
+              #   trace flags associated with the current context.
+              # @param [optional OpenTelemetry::SDK::Resources::Resource] resource The
+              #   source of the log, desrived from the LoggerProvider.
+              # @param [optional OpenTelemetry::SDK::InstrumentationScope] instrumentation_scope
+              #   The instrumentation scope, derived from the emitting Logger
+              #
+              #
+              # @return [LogRecord]
+              def initialize(
+                timestamp: nil,
+                observed_timestamp: nil,
+                severity_text: nil,
+                severity_number: nil,
+                body: nil,
+                attributes: nil,
+                trace_id: nil,
+                span_id: nil,
+                trace_flags: nil,
+                resource: nil,
+                instrumentation_scope: nil
+              )
+                @timestamp = timestamp
+                @observed_timestamp = observed_timestamp || timestamp || Time.now
+                @severity_text = severity_text
+                @severity_number = severity_number
+                @body = body
+                @attributes = attributes.nil? ? nil : Hash[attributes] # We need a mutable copy of attributes
+                @trace_id = trace_id
+                @span_id = span_id
+                @trace_flags = trace_flags
+                @resource = resource
+                @instrumentation_scope = instrumentation_scope
+                @total_recorded_attributes = @attributes&.size || 0
+              end
+
+              def to_log_record_data
+                LogRecordData.new(
+                  to_integer_nanoseconds(@timestamp),
+                  to_integer_nanoseconds(@observed_timestamp),
+                  @severity_text,
+                  @severity_number,
+                  @body,
+                  @attributes,
+                  @trace_id,
+                  @span_id,
+                  @trace_flags,
+                  @resource,
+                  @instrumentation_scope,
+                  @total_recorded_attributes
+                )
+              end
+
+              private
+
+              def to_integer_nanoseconds(timestamp)
+                return unless timestamp.is_a?(Time)
+
+                (timestamp.to_r * 10**9).to_i
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# 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
+            # LogRecordData is a Struct containing {LogRecord} data for export.
+            LogRecordData = Struct.new(:timestamp,                 # optional Integer nanoseconds since Epoch
+                                      :observed_timestamp,        # Integer nanoseconds since Epoch
+                                      :severity_text,             # optional String
+                                      :severity_number,           # optional Integer
+                                      :body,                      # optional String, Numeric, Boolean, Array<String, Numeric, Boolean>, Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}
+                                      :attributes, # optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}
+                                      :trace_id,                  # optional String (16-byte binary)
+                                      :span_id,                   # optional String (8-byte binary)
+                                      :trace_flags,               # optional Integer (8-bit byte of bit flags)
+                                      :resource,                  # optional OpenTelemetry::SDK::Resources::Resource
+                                      :instrumentation_scope,     # optional OpenTelemetry::SDK::InstrumentationScope
+                                      :total_recorded_attributes) # Integer
+          end
+        end
+      end
+    end
+  end
+end

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