scout_apm_logging 1.1.0 → 2.0.0

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

@@ -1,31 +0,0 @@
-# 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_limits.rb

@@ -1,49 +0,0 @@
-# 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
-            # Class that holds log record attribute limit parameters.
-            class LogRecordLimits
-              # The global default max number of attributes per {LogRecord}.
-              attr_reader :attribute_count_limit
-
-              # The global default max length of attribute value per {LogRecord}.
-              attr_reader :attribute_length_limit
-
-              # Returns a {LogRecordLimits} with the desired values.
-              #
-              # @return [LogRecordLimits] with the desired values.
-              # @raise [ArgumentError] if any of the max numbers are not positive.
-              def initialize(attribute_count_limit: Integer(::OpenTelemetry::Common::Utilities.config_opt(
-                                                              'OTEL_LOG_RECORD_ATTRIBUTE_COUNT_LIMIT',
-                                                              'OTEL_ATTRIBUTE_COUNT_LIMIT',
-                                                              default: 128
-                                                            )),
-                            attribute_length_limit: ::OpenTelemetry::Common::Utilities.config_opt(
-                              'OTEL_LOG_RECORD_ATTRIBUTE_VALUE_LENGTH_LIMIT',
-                              'OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT'
-                            ))
-                raise ArgumentError, 'attribute_count_limit must be positive' unless attribute_count_limit.positive?
-                raise ArgumentError, 'attribute_length_limit must not be less than 32' unless attribute_length_limit.nil? || Integer(attribute_length_limit) >= 32
-
-                @attribute_count_limit = attribute_count_limit
-                @attribute_length_limit = attribute_length_limit.nil? ? nil : Integer(attribute_length_limit)
-              end
-
-              # The default {LogRecordLimits}.
-              DEFAULT = new
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-# 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 [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)
-                Export::SUCCESS
-              end
-
-              # Called when {LoggerProvider#shutdown} is called.
-              #
-              # @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)
-                Export::SUCCESS
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,98 +0,0 @@
-# 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 [optional String] severity_text Original string representation of
-              #   the severity as it is known at the source. Also known as log level.
-              # @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)
-                current_span = ::OpenTelemetry::Trace.current_span(context)
-                span_context = current_span.context unless current_span == ::OpenTelemetry::Trace::Span::INVALID
-
-                @logger_provider.on_emit(timestamp: timestamp,
-                                        observed_timestamp: observed_timestamp,
-                                        severity_text: severity_text,
-                                        severity_number: severity_number,
-                                        body: body,
-                                        attributes: attributes,
-                                        trace_id: trace_id || span_context&.trace_id,
-                                        span_id: span_id || span_context&.span_id,
-                                        trace_flags: trace_flags || span_context&.trace_flags,
-                                        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

@@ -1,170 +0,0 @@
-# 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
-              Key = Struct.new(:name, :version)
-              private_constant(:Key)
-
-              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.
-              # @param [optional LogRecordLimits] log_record_limits The limits for
-              #   attributes count and attribute length for LogRecords.
-              #
-              # @return [OpenTelemetry::SDK::Logs::LoggerProvider]
-              def initialize(resource: OpenTelemetry::SDK::Resources::Resource.create, log_record_limits: LogRecordLimits::DEFAULT)
-                @log_record_processors = []
-                @log_record_limits = log_record_limits
-                @mutex = Mutex.new
-                @resource = resource
-                @stopped = false
-                @registry = {}
-                @registry_mutex = Mutex.new
-              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
-
-                @registry_mutex.synchronize do
-                  @registry[Key.new(name, version)] ||= Logger.new(name, version, self)
-                end
-              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)
-                return if @stopped
-
-                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_limits: @log_record_limits)
-
-                @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

@@ -1,20 +0,0 @@
-# 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.2.0'
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# 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'
-require_relative 'logs/log_record_limits'
-
-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