scout_apm_logging 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0d9d5323e07f8b2fe838a030d93123d00a5fb6e289fe7bc78d7ac0bcc2ebc79
-  data.tar.gz: e00d25c837617410f02ec4d6523fd5afdbb37efa633b3ecaf625f5929a1b960f
+  metadata.gz: ae315d1586cbc29835019dd459208978f033398a7427dedd7dd36b49c7fd6296
+  data.tar.gz: 734acfcbaae4e9a424710889d30a2cde7cc6904d4e56d304ac173a327e8c1fd0
 SHA512:
-  metadata.gz: 0d126cf0149770bb461251442e7cf2fdb40c536076d3d09131ad3d0df3763e10fb5ec4bb44ceb780b11851ab4c2276934b476033d77bcbb7fa8db7e89eed0339
-  data.tar.gz: 2c441b2bf745ca77aa154d44a536509de405051b8c363d9d8ccb95a6828fa77110b0bc3e196cf3044e7d0e1b837b295de855b428c64e8e6c7fa39d910fcb3d15
+  metadata.gz: 36adc77a85764f440b3bf8170528c28d6957e82c8e729bc03dd74a533f0c9d9c4a6231e5aae35dbad5d92a2cb77f446f004770c5998cb4559220899c147cd239
+  data.tar.gz: d89fdad7d8d5efe7678055180fe28e3217b5adbd8cdcbfb70cee68fd93ee9e9c8b77ed56c6e19088df8919c55dbbd8a60a69e6dac5f4b597047271399d9f4f9b

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 1.1.0
+* Bump vendored SDK version to 0.2.0.
+
 ## 1.0.3
 * Add capturing of queue for background jobs.
 * Fix entrypoint name capturing for namespaced controllers.

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

@@ -36,7 +36,7 @@ module ScoutApm
           ).on_emit(
             severity_text: severity,
             severity_number: ::Logger::Severity.const_get(severity),
-            attributes: attributes_to_log,
+            attributes: attributes_to_log.transform_keys(&:to_s),
             timestamp: time,
             body: msg,
             context: ::OpenTelemetry::Context.current

data/lib/scout_apm/logging/loggers/opentelemetry/exporter/exporter/otlp/logs_exporter.rb

@@ -27,52 +27,53 @@ module ScoutApm
               SUCCESS = OpenTelemetry::SDK::Logs::Export::SUCCESS
               FAILURE = OpenTelemetry::SDK::Logs::Export::FAILURE
               private_constant(:SUCCESS, :FAILURE)
-
+    
               # Default timeouts in seconds.
               KEEP_ALIVE_TIMEOUT = 30
               RETRY_COUNT = 5
-              WRITE_TIMEOUT_SUPPORTED = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
-              private_constant(:KEEP_ALIVE_TIMEOUT, :RETRY_COUNT, :WRITE_TIMEOUT_SUPPORTED)
-
+              private_constant(:KEEP_ALIVE_TIMEOUT, :RETRY_COUNT)
+    
               ERROR_MESSAGE_INVALID_HEADERS = 'headers must be a String with comma-separated URL Encoded UTF-8 k=v pairs or a Hash'
               private_constant(:ERROR_MESSAGE_INVALID_HEADERS)
-
+    
               DEFAULT_USER_AGENT = "OTel-OTLP-Exporter-Ruby/#{OpenTelemetry::Exporter::OTLP::VERSION} Ruby/#{RUBY_VERSION} (#{RUBY_PLATFORM}; #{RUBY_ENGINE}/#{RUBY_ENGINE_VERSION})".freeze
-
+    
               def self.ssl_verify_mode
-                if ENV.key?('OTEL_RUBY_EXPORTER_OTLP_SSL_VERIFY_PEER')
+                if ENV['OTEL_RUBY_EXPORTER_OTLP_SSL_VERIFY_PEER'] == 'true'
                   OpenSSL::SSL::VERIFY_PEER
-                elsif ENV.key?('OTEL_RUBY_EXPORTER_OTLP_SSL_VERIFY_NONE')
+                elsif ENV['OTEL_RUBY_EXPORTER_OTLP_SSL_VERIFY_NONE'] == 'true'
                   OpenSSL::SSL::VERIFY_NONE
                 else
                   OpenSSL::SSL::VERIFY_PEER
                 end
               end
-
+    
               def initialize(endpoint: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_ENDPOINT', 'OTEL_EXPORTER_OTLP_ENDPOINT', default: 'http://localhost:4318/v1/logs'),
-                            certificate_file: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE', 'OTEL_EXPORTER_OTLP_CERTIFICATE'),
-                            ssl_verify_mode: LogsExporter.ssl_verify_mode,
-                            headers: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_HEADERS', 'OTEL_EXPORTER_OTLP_HEADERS', default: {}),
-                            compression: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_COMPRESSION', 'OTEL_EXPORTER_OTLP_COMPRESSION', default: 'gzip'),
-                            timeout: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_TIMEOUT', 'OTEL_EXPORTER_OTLP_TIMEOUT', default: 10))
-                raise ArgumentError, "invalid url for OTLP::Exporter #{endpoint}" unless ::OpenTelemetry::Common::Utilities.valid_url?(endpoint)
+                              certificate_file: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_CERTIFICATE', 'OTEL_EXPORTER_OTLP_CERTIFICATE'),
+                              client_certificate_file: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_CLIENT_CERTIFICATE', 'OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE'),
+                              client_key_file: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_CLIENT_KEY', 'OTEL_EXPORTER_OTLP_CLIENT_KEY'),
+                              ssl_verify_mode: LogsExporter.ssl_verify_mode,
+                              headers: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_HEADERS', 'OTEL_EXPORTER_OTLP_HEADERS', default: {}),
+                              compression: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_COMPRESSION', 'OTEL_EXPORTER_OTLP_COMPRESSION', default: 'gzip'),
+                              timeout: ::OpenTelemetry::Common::Utilities.config_opt('OTEL_EXPORTER_OTLP_LOGS_TIMEOUT', 'OTEL_EXPORTER_OTLP_TIMEOUT', default: 10))
+                raise ArgumentError, "invalid url for OTLP::Logs::LogsExporter #{endpoint}" unless ::OpenTelemetry::Common::Utilities.valid_url?(endpoint)
                 raise ArgumentError, "unsupported compression key #{compression}" unless compression.nil? || %w[gzip none].include?(compression)
-
+    
                 @uri = if endpoint == ENV['OTEL_EXPORTER_OTLP_ENDPOINT']
-                        URI.join(endpoint, 'v1/logs')
-                      else
-                        URI(endpoint)
-                      end
-
-                @http = http_connection(@uri, ssl_verify_mode, certificate_file)
-
+                          URI.join(endpoint, 'v1/logs')
+                        else
+                          URI(endpoint)
+                        end
+    
+                @http = http_connection(@uri, ssl_verify_mode, certificate_file, client_certificate_file, client_key_file)
+    
                 @path = @uri.path
                 @headers = prepare_headers(headers)
                 @timeout = timeout.to_f
                 @compression = compression
                 @shutdown = false
               end
-
+    
               # Called to export sampled {OpenTelemetry::SDK::Logs::LogRecordData} structs.
               #
               # @param [Enumerable<OpenTelemetry::SDK::Logs::LogRecordData>] log_record_data the
@@ -83,10 +84,10 @@ module ScoutApm
               def export(log_record_data, timeout: nil)
                 OpenTelemetry.logger.error('Logs Exporter tried to export, but it has already shut down') if @shutdown
                 return FAILURE if @shutdown
-
+    
                 send_bytes(encode(log_record_data), timeout: timeout)
               end
-
+    
               # Called when {OpenTelemetry::SDK::Logs::LoggerProvider#force_flush} is called, if
               # this exporter is registered to a {OpenTelemetry::SDK::Logs::LoggerProvider}
               # object.
@@ -95,7 +96,7 @@ module ScoutApm
               def force_flush(timeout: nil)
                 SUCCESS
               end
-
+    
               # Called when {OpenTelemetry::SDK::Logs::LoggerProvider#shutdown} is called, if
               # this exporter is registered to a {OpenTelemetry::SDK::Logs::LoggerProvider}
               # object.
@@ -106,18 +107,24 @@ module ScoutApm
                 @http.finish if @http.started?
                 SUCCESS
               end
-
+    
               private
-
-              def http_connection(uri, ssl_verify_mode, certificate_file)
+    
+              def handle_http_error(response)
+                OpenTelemetry.handle_error(message: "OTLP logs exporter received #{response.class.name}, http.code=#{response.code}, for uri: '#{@path}'")
+              end
+    
+              def http_connection(uri, ssl_verify_mode, certificate_file, client_certificate_file, client_key_file)
                 http = Net::HTTP.new(uri.host, uri.port)
                 http.use_ssl = uri.scheme == 'https'
                 http.verify_mode = ssl_verify_mode
                 http.ca_file = certificate_file unless certificate_file.nil?
+                http.cert = OpenSSL::X509::Certificate.new(File.read(client_certificate_file)) unless client_certificate_file.nil?
+                http.key = OpenSSL::PKey::RSA.new(File.read(client_key_file)) unless client_key_file.nil?
                 http.keep_alive_timeout = KEEP_ALIVE_TIMEOUT
                 http
               end
-
+    
               # The around_request is a private method that provides an extension
               # point for the exporters network calls. The default behaviour
               # is to not record these operations.
@@ -128,10 +135,10 @@ module ScoutApm
               def around_request
                 ::OpenTelemetry::Common::Utilities.untraced { yield } # rubocop:disable Style/ExplicitBlockArgument
               end
-
+    
               def send_bytes(bytes, timeout:) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
                 return FAILURE if bytes.nil?
-
+    
                 request = Net::HTTP::Post.new(@path)
                 if @compression == 'gzip'
                   request.add_field('Content-Encoding', 'gzip')
@@ -139,39 +146,41 @@ module ScoutApm
                 else
                   body = bytes
                 end
-
+    
                 request.body = body
                 request.add_field('Content-Type', 'application/x-protobuf')
                 @headers.each { |key, value| request.add_field(key, value) }
-
+    
                 retry_count = 0
                 timeout ||= @timeout
                 start_time = ::OpenTelemetry::Common::Utilities.timeout_timestamp
-
+    
                 around_request do
                   remaining_timeout = ::OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
                   return FAILURE if remaining_timeout.zero?
-
+    
                   @http.open_timeout = remaining_timeout
                   @http.read_timeout = remaining_timeout
-                  @http.write_timeout = remaining_timeout if WRITE_TIMEOUT_SUPPORTED
+                  @http.write_timeout = remaining_timeout
                   @http.start unless @http.started?
-                  response = measure_request_duration { @http.request(request) }
-
+                  response = @http.request(request)
+    
                   case response
                   when Net::HTTPOK
                     response.body # Read and discard body
                     SUCCESS
                   when Net::HTTPServiceUnavailable, Net::HTTPTooManyRequests
                     response.body # Read and discard body
-                    redo if backoff?(retry_after: response['Retry-After'], retry_count: retry_count += 1, reason: response.code)
+                    handle_http_error(response)
+                    redo if backoff?(retry_after: response['Retry-After'], retry_count: retry_count += 1)
                     FAILURE
                   when Net::HTTPRequestTimeOut, Net::HTTPGatewayTimeOut, Net::HTTPBadGateway
                     response.body # Read and discard body
-                    redo if backoff?(retry_count: retry_count += 1, reason: response.code)
+                    handle_http_error(response)
+                    redo if backoff?(retry_count: retry_count += 1)
                     FAILURE
                   when Net::HTTPNotFound
-                    OpenTelemetry.handle_error(message: "OTLP exporter received http.code=404 for uri: '#{@path}'")
+                    handle_http_error(response)
                     FAILURE
                   when Net::HTTPBadRequest, Net::HTTPClientError, Net::HTTPServerError
                     log_status(response.body)
@@ -179,28 +188,35 @@ module ScoutApm
                   when Net::HTTPRedirection
                     @http.finish
                     handle_redirect(response['location'])
-                    redo if backoff?(retry_after: 0, retry_count: retry_count += 1, reason: response.code)
+                    redo if backoff?(retry_after: 0, retry_count: retry_count += 1)
                   else
                     @http.finish
+                    handle_http_error(response)
                     FAILURE
                   end
-                rescue Net::OpenTimeout, Net::ReadTimeout
-                  retry if backoff?(retry_count: retry_count += 1, reason: 'timeout')
+                rescue Net::OpenTimeout, Net::ReadTimeout => e
+                  OpenTelemetry.handle_error(exception: e)
+                  retry if backoff?(retry_count: retry_count += 1)
                   return FAILURE
-                rescue OpenSSL::SSL::SSLError
-                  retry if backoff?(retry_count: retry_count += 1, reason: 'openssl_error')
+                rescue OpenSSL::SSL::SSLError => e
+                  OpenTelemetry.handle_error(exception: e)
+                  retry if backoff?(retry_count: retry_count += 1)
                   return FAILURE
-                rescue SocketError
-                  retry if backoff?(retry_count: retry_count += 1, reason: 'socket_error')
+                rescue SocketError => e
+                  OpenTelemetry.handle_error(exception: e)
+                  retry if backoff?(retry_count: retry_count += 1)
                   return FAILURE
                 rescue SystemCallError => e
-                  retry if backoff?(retry_count: retry_count += 1, reason: e.class.name)
+                  retry if backoff?(retry_count: retry_count += 1)
+                  OpenTelemetry.handle_error(exception: e)
                   return FAILURE
-                rescue EOFError
-                  retry if backoff?(retry_count: retry_count += 1, reason: 'eof_error')
+                rescue EOFError => e
+                  OpenTelemetry.handle_error(exception: e)
+                  retry if backoff?(retry_count: retry_count += 1)
                   return FAILURE
-                rescue Zlib::DataError
-                  retry if backoff?(retry_count: retry_count += 1, reason: 'zlib_error')
+                rescue Zlib::DataError => e
+                  OpenTelemetry.handle_error(exception: e)
+                  retry if backoff?(retry_count: retry_count += 1)
                   return FAILURE
                 rescue StandardError => e
                   OpenTelemetry.handle_error(exception: e, message: 'unexpected error in OTLP::Exporter#send_bytes')
@@ -210,37 +226,27 @@ module ScoutApm
                 # Reset timeouts to defaults for the next call.
                 @http.open_timeout = @timeout
                 @http.read_timeout = @timeout
-                @http.write_timeout = @timeout if WRITE_TIMEOUT_SUPPORTED
+                @http.write_timeout = @timeout
               end
-
+    
               def handle_redirect(location)
                 # TODO: figure out destination and reinitialize @http and @path
               end
-
+    
               def log_status(body)
                 status = Google::Rpc::Status.decode(body)
                 details = status.details.map do |detail|
                   klass_or_nil = ::Google::Protobuf::DescriptorPool.generated_pool.lookup(detail.type_name).msgclass
                   detail.unpack(klass_or_nil) if klass_or_nil
                 end.compact
-                OpenTelemetry.handle_error(message: "OTLP exporter received rpc.Status{message=#{status.message}, details=#{details}}")
+                OpenTelemetry.handle_error(message: "OTLP logs exporter received rpc.Status{message=#{status.message}, details=#{details}}")
               rescue StandardError => e
                 OpenTelemetry.handle_error(exception: e, message: 'unexpected error decoding rpc.Status in OTLP::Exporter#log_status')
               end
-
-              def measure_request_duration
-                start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-                begin
-                  yield
-                ensure
-                  stop = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-                  1000.0 * (stop - start)
-                end
-              end
-
-              def backoff?(retry_count:, reason:, retry_after: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    
+              def backoff?(retry_count:, retry_after: nil) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
                 return false if retry_count > RETRY_COUNT
-
+    
                 sleep_interval = nil
                 unless retry_after.nil?
                   sleep_interval =
@@ -258,11 +264,11 @@ module ScoutApm
                   sleep_interval = nil unless sleep_interval&.positive?
                 end
                 sleep_interval ||= rand(2**retry_count)
-
+    
                 sleep(sleep_interval)
                 true
               end
-
+    
               def encode(log_record_data) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
                 Opentelemetry::Proto::Collector::Logs::V1::ExportLogsServiceRequest.encode(
                   Opentelemetry::Proto::Collector::Logs::V1::ExportLogsServiceRequest.new(
@@ -292,7 +298,7 @@ module ScoutApm
                 OpenTelemetry.handle_error(exception: e, message: 'unexpected error in OTLP::Exporter#encode')
                 nil
               end
-
+    
               def as_otlp_log_record(log_record_data)
                 Opentelemetry::Proto::Logs::V1::LogRecord.new(
                   time_unix_nano: log_record_data.timestamp,
@@ -307,7 +313,7 @@ module ScoutApm
                   span_id: log_record_data.span_id
                 )
               end
-
+    
               def as_otlp_key_value(key, value)
                 Opentelemetry::Proto::Common::V1::KeyValue.new(key: key, value: as_otlp_any_value(value))
               rescue Encoding::UndefinedConversionError => e
@@ -315,7 +321,7 @@ module ScoutApm
                 OpenTelemetry.handle_error(exception: e, message: "encoding error for key #{key} and value #{encoded_value}")
                 Opentelemetry::Proto::Common::V1::KeyValue.new(key: key, value: as_otlp_any_value('Encoding Error'))
               end
-
+    
               def as_otlp_any_value(value)
                 result = Opentelemetry::Proto::Common::V1::AnyValue.new
                 case value
@@ -333,6 +339,22 @@ module ScoutApm
                 end
                 result
               end
+    
+              def prepare_headers(config_headers)
+                headers = case config_headers
+                          when String then parse_headers(config_headers)
+                          when Hash then config_headers.dup
+                          else
+                            raise ArgumentError, ERROR_MESSAGE_INVALID_HEADERS
+                          end
+    
+                headers['User-Agent'] = "#{headers.fetch('User-Agent', '')} #{DEFAULT_USER_AGENT}".strip
+    
+                headers
+              end
+
+              # NOTE: This has been removed in newer versions of the OpenTelemetry Ruby Logs SDK,
+              # but we need it for backward compatibility with the protobuf definitions.
 
               # TODO: maybe don't translate the severity number, but translate the severity text into
               # the number if the number is nil? Poss. change to allow for adding your own
@@ -347,24 +369,11 @@ module ScoutApm
                 when 5 then Opentelemetry::Proto::Logs::V1::SeverityNumber::SEVERITY_NUMBER_UNSPECIFIED
                 end
               end
-
-              def prepare_headers(config_headers)
-                headers = case config_headers
-                          when String then parse_headers(config_headers)
-                          when Hash then config_headers.dup
-                          else
-                            raise ArgumentError, ERROR_MESSAGE_INVALID_HEADERS
-                          end
-
-                headers['User-Agent'] = "#{headers.fetch('User-Agent', '')} #{DEFAULT_USER_AGENT}".strip
-
-                headers
-              end
-
+    
               def parse_headers(raw)
                 entries = raw.split(',')
                 raise ArgumentError, ERROR_MESSAGE_INVALID_HEADERS if entries.empty?
-
+    
                 entries.each_with_object({}) do |entry, headers|
                   k, v = entry.split('=', 2).map(&CGI.method(:unescape))
                   begin
@@ -376,7 +385,7 @@ module ScoutApm
                     raise e, ERROR_MESSAGE_INVALID_HEADERS
                   end
                   raise ArgumentError, ERROR_MESSAGE_INVALID_HEADERS if k.empty? || v.empty?
-
+    
                   headers[k] = v
                 end
               end

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

@@ -3,7 +3,6 @@
 # Copyright The OpenTelemetry Authors
 #
 # SPDX-License-Identifier: Apache-2.0
-
 module ScoutApm
   module Logging
     module Loggers
@@ -41,9 +40,8 @@ module ScoutApm
                               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)),
+                              max_export_batch_size: Integer(ENV.fetch('OTEL_BLRP_MAX_EXPORT_BATCH_SIZE', 512)),
                               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'

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

@@ -12,6 +12,10 @@ module ScoutApm
           module Logs
             # Implementation of OpenTelemetry::Logs::LogRecord that records log events.
             class LogRecord < OpenTelemetry::Logs::LogRecord
+              EMPTY_ATTRIBUTES = {}.freeze
+
+              private_constant :EMPTY_ATTRIBUTES
+
               attr_accessor :timestamp,
                             :observed_timestamp,
                             :severity_text,
@@ -52,6 +56,8 @@ module ScoutApm
               #   source of the log, desrived from the LoggerProvider.
               # @param [optional OpenTelemetry::SDK::InstrumentationScope] instrumentation_scope
               #   The instrumentation scope, derived from the emitting Logger
+              # @param [optional] OpenTelemetry::SDK::LogRecordLimits] log_record_limits
+              #   Attribute limits
               #
               #
               # @return [LogRecord]
@@ -66,7 +72,8 @@ module ScoutApm
                 span_id: nil,
                 trace_flags: nil,
                 resource: nil,
-                instrumentation_scope: nil
+                instrumentation_scope: nil,
+                log_record_limits: nil
               )
                 @timestamp = timestamp
                 @observed_timestamp = observed_timestamp || timestamp || Time.now
@@ -79,7 +86,10 @@ module ScoutApm
                 @trace_flags = trace_flags
                 @resource = resource
                 @instrumentation_scope = instrumentation_scope
+                @log_record_limits = log_record_limits || LogRecordLimits::DEFAULT
                 @total_recorded_attributes = @attributes&.size || 0
+
+                trim_attributes(@attributes)
               end
 
               def to_log_record_data
@@ -106,6 +116,51 @@ module ScoutApm
 
                 (timestamp.to_r * 10**9).to_i
               end
+
+              def trim_attributes(attributes)
+                return if attributes.nil?
+
+                # truncate total attributes
+                truncate_attributes(attributes, @log_record_limits.attribute_count_limit)
+
+                # truncate attribute values
+                truncate_attribute_values(attributes, @log_record_limits.attribute_length_limit)
+
+                # validate attributes
+                validate_attributes(attributes)
+
+                nil
+              end
+
+              def truncate_attributes(attributes, attribute_limit)
+                excess = attributes.size - attribute_limit
+                excess.times { attributes.shift } if excess.positive?
+              end
+
+              def validate_attributes(attrs)
+                # Similar to Internal.valid_attributes?, but with different messages
+                # Future refactor opportunity: https://github.com/open-telemetry/opentelemetry-ruby/issues/1739
+                attrs.keep_if do |k, v|
+                  if !::OpenTelemetry::SDK::Internal.valid_key?(k)
+                    OpenTelemetry.handle_error(message: "invalid log record attribute key type #{k.class}, #{k} on record: '#{body}'")
+                    return false
+                  elsif !::OpenTelemetry::SDK::Internal.valid_value?(v)
+                    OpenTelemetry.handle_error(message: "invalid log record attribute value type #{v.class} for key '#{k}' on record: '#{body}'")
+                    return false
+                  end
+
+                  true
+                end
+              end
+
+              def truncate_attribute_values(attributes, attribute_length_limit)
+                return EMPTY_ATTRIBUTES if attributes.nil?
+                return attributes if attribute_length_limit.nil?
+
+                attributes.transform_values! { |value| ::OpenTelemetry::Common::Utilities.truncate_attribute_value(value, attribute_length_limit) }
+
+                attributes
+              end
             end
           end
         end

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

@@ -16,7 +16,7 @@ module ScoutApm
                                       :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>}
+                                      :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)

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

@@ -0,0 +1,49 @@
+# 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

@@ -3,7 +3,6 @@
 # Copyright The OpenTelemetry Authors
 #
 # SPDX-License-Identifier: Apache-2.0
-
 module ScoutApm
   module Logging
     module Loggers
@@ -29,7 +28,7 @@ module ScoutApm
               # the process after an invocation, but before the `Processor` exports
               # the completed spans.
               #
-              # @param [Numeric] timeout An optional timeout in seconds.
+              # @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)
@@ -38,7 +37,7 @@ module ScoutApm
 
               # Called when {LoggerProvider#shutdown} is called.
               #
-              # @param [Numeric] timeout An optional timeout in seconds.
+              # @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)

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

@@ -37,6 +37,8 @@ module ScoutApm
               # @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
@@ -72,6 +74,8 @@ module ScoutApm
                           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,
@@ -79,9 +83,9 @@ module ScoutApm
                                         severity_number: severity_number,
                                         body: body,
                                         attributes: attributes,
-                                        trace_id: nil,
-                                        span_id: nil,
-                                        trace_flags: nil,
+                                        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

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

@@ -12,6 +12,9 @@ module ScoutApm
           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'
 
@@ -21,13 +24,18 @@ module ScoutApm
               #
               # @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)
+              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.
@@ -44,7 +52,9 @@ module ScoutApm
                     "invalid name. Name provided: #{name.inspect}")
                 end
 
-                Logger.new(name, version, self)
+                @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
@@ -134,6 +144,7 @@ module ScoutApm
                           trace_flags: nil,
                           instrumentation_scope: nil,
                           context: nil)
+                return if @stopped
 
                 log_record = LogRecord.new(timestamp: timestamp,
                                           observed_timestamp: observed_timestamp,
@@ -145,7 +156,8 @@ module ScoutApm
                                           span_id: span_id,
                                           trace_flags: trace_flags,
                                           resource: @resource,
-                                          instrumentation_scope: instrumentation_scope)
+                                          instrumentation_scope: instrumentation_scope,
+                                          log_record_limits: @log_record_limits)
 
                 @log_record_processors.each { |processor| processor.on_emit(log_record, context) }
               end

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

@@ -11,10 +11,10 @@ module ScoutApm
         module SDK
           module Logs
             # Current OpenTelemetry logs sdk version
-            VERSION = '0.1.0'
+            VERSION = '0.2.0'
           end
         end
       end
     end
   end
-end
+end

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

@@ -11,6 +11,7 @@ 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

data/lib/scout_apm/logging/version.rb

@@ -2,6 +2,6 @@
 
 module ScoutApm
   module Logging
-    VERSION = '1.0.3'
+    VERSION = '1.1.0'
   end
 end

data/scout_apm_logging.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.authors     = 'Scout APM'
   s.email       = ['support@scoutapp.com']
   s.homepage    = 'https://github.com/scoutapp/scout_apm_ruby_logging'
-  s.summary     = 'Ruby Logging Support'
+  s.summary     = 'Managed log monitoring for Ruby applications.'
   s.description = 'Sets up log monitoring for Scout APM Ruby clients.'
   s.license     = 'MIT'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm_logging
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Scout APM
@@ -208,6 +208,7 @@ files:
 - lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/export/log_record_exporter.rb
 - lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/log_record.rb
 - lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/log_record_data.rb
+- lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/log_record_limits.rb
 - lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/log_record_processor.rb
 - lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/logger.rb
 - lib/scout_apm/logging/loggers/opentelemetry/sdk/logs/logger_provider.rb
@@ -251,7 +252,7 @@ requirements: []
 rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
-summary: Ruby Logging Support
+summary: Managed log monitoring for Ruby applications.
 test_files:
 - spec/data/config_test_1.yml
 - spec/data/mock_config.yml