opentelemetry-sdk 0.13.1 → 1.0.0.rc1

data/lib/opentelemetry/sdk/trace/config/trace_config.rb

@@ -16,6 +16,9 @@ module OpenTelemetry
           # The global default max number of attributes per {Span}.
           attr_reader :max_attributes_count
 
+          # The global default max length of attribute value per {Span}.
+          attr_reader :max_attributes_length
+
           # The global default max number of {OpenTelemetry::SDK::Trace::Event}s per {Span}.
           attr_reader :max_events_count
 
@@ -32,13 +35,15 @@ module OpenTelemetry
           #
           # @return [TraceConfig] with the desired values.
           # @raise [ArgumentError] if any of the max numbers are not positive.
-          def initialize(sampler: sampler_from_environment(Samplers.parent_based(root: Samplers::ALWAYS_ON)),
-                         max_attributes_count: Integer(ENV.fetch('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT', 1000)),
-                         max_events_count: Integer(ENV.fetch('OTEL_SPAN_EVENT_COUNT_LIMIT', 1000)),
-                         max_links_count: Integer(ENV.fetch('OTEL_SPAN_LINK_COUNT_LIMIT', 1000)),
+          def initialize(sampler: sampler_from_environment(Samplers.parent_based(root: Samplers::ALWAYS_ON)), # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+                         max_attributes_count: Integer(ENV.fetch('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT', 128)),
+                         max_attributes_length: ENV['OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT'],
+                         max_events_count: Integer(ENV.fetch('OTEL_SPAN_EVENT_COUNT_LIMIT', 128)),
+                         max_links_count: Integer(ENV.fetch('OTEL_SPAN_LINK_COUNT_LIMIT', 128)),
                          max_attributes_per_event: max_attributes_count,
                          max_attributes_per_link: max_attributes_count)
             raise ArgumentError, 'max_attributes_count must be positive' unless max_attributes_count.positive?
+            raise ArgumentError, 'max_attributes_length must not be less than 32' unless max_attributes_length.nil? || Integer(max_attributes_length) >= 32
             raise ArgumentError, 'max_events_count must be positive' unless max_events_count.positive?
             raise ArgumentError, 'max_links_count must be positive' unless max_links_count.positive?
             raise ArgumentError, 'max_attributes_per_event must be positive' unless max_attributes_per_event.positive?
@@ -46,6 +51,7 @@ module OpenTelemetry
 
             @sampler = sampler
             @max_attributes_count = max_attributes_count
+            @max_attributes_length = max_attributes_length.nil? ? nil : Integer(max_attributes_length)
             @max_events_count = max_events_count
             @max_links_count = max_links_count
             @max_attributes_per_event = max_attributes_per_event
@@ -56,13 +62,13 @@ module OpenTelemetry
           private
 
           def sampler_from_environment(default_sampler) # rubocop:disable Metrics/CyclomaticComplexity
-            case ENV['OTEL_TRACE_SAMPLER']
+            case ENV['OTEL_TRACES_SAMPLER']
             when 'always_on' then Samplers::ALWAYS_ON
             when 'always_off' then Samplers::ALWAYS_OFF
-            when 'traceidratio' then Samplers.trace_id_ratio_based(Float(ENV.fetch('OTEL_TRACE_SAMPLER_ARG', 1.0)))
+            when 'traceidratio' then Samplers.trace_id_ratio_based(Float(ENV.fetch('OTEL_TRACES_SAMPLER_ARG', 1.0)))
             when 'parentbased_always_on' then Samplers.parent_based(root: Samplers::ALWAYS_ON)
             when 'parentbased_always_off' then Samplers.parent_based(root: Samplers::ALWAYS_OFF)
-            when 'parentbased_traceidratio' then Samplers.parent_based(root: Samplers.trace_id_ratio_based(Float(ENV.fetch('OTEL_TRACE_SAMPLER_ARG', 1.0))))
+            when 'parentbased_traceidratio' then Samplers.parent_based(root: Samplers.trace_id_ratio_based(Float(ENV.fetch('OTEL_TRACES_SAMPLER_ARG', 1.0))))
             else default_sampler
             end
           rescue StandardError => e

data/lib/opentelemetry/sdk/trace/event.rb

@@ -7,42 +7,13 @@
 module OpenTelemetry
   module SDK
     module Trace
-      # A text annotation with a set of attributes and a timestamp.
-      class Event
-        EMPTY_ATTRIBUTES = {}.freeze
-
-        private_constant :EMPTY_ATTRIBUTES
-
-        # Returns the name of this event
-        #
-        # @return [String]
-        attr_reader :name
-
-        # Returns the frozen attributes for this event
-        #
-        # @return [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
-        attr_reader :attributes
-
-        # Returns the timestamp for this event
-        #
-        # @return [Time]
-        attr_reader :timestamp
-
-        # Returns a new immutable {Event}.
-        #
-        # @param [String] name The name of this event
-        # @param [optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
-        #   attributes A hash of attributes for this event. Attributes will be
-        #   frozen during Event initialization.
-        # @param [optional Time] timestamp The timestamp for this event.
-        #   Defaults to Time.now.
-        # @return [Event]
-        def initialize(name:, attributes: nil, timestamp: nil)
-          @name = name
-          @attributes = attributes.freeze || EMPTY_ATTRIBUTES
-          @timestamp = timestamp || Time.now
-        end
-      end
+      # A text annotation with a set of attributes and a timestamp for export.
+      #
+      # Field types are as follows:
+      #  name: String
+      #  attributes: frozen Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}
+      #  timestamp: Integer nanoseconds since Epoch
+      Event = Struct.new(:name, :attributes, :timestamp)
     end
   end
 end

data/lib/opentelemetry/sdk/trace/export/batch_span_processor.rb

@@ -28,7 +28,8 @@ module OpenTelemetry
         class BatchSpanProcessor # rubocop:disable Metrics/ClassLength
           # Returns a new instance of the {BatchSpanProcessor}.
           #
-          # @param [SpanExporter] exporter
+          # @param [SpanExporter] exporter the (duck type) SpanExporter to where the
+          #   recorded Spans are pushed after batching.
           # @param [Numeric] exporter_timeout the delay interval between two
           #   consecutive exports. Defaults to the value of the OTEL_BSP_EXPORT_TIMEOUT
           #   environment variable, if set, or 30,000 (30 seconds).
@@ -43,7 +44,7 @@ module OpenTelemetry
           #   variable, if set, or 512.
           #
           # @return a new instance of the {BatchSpanProcessor}.
-          def initialize(exporter:,
+          def initialize(exporter,
                          exporter_timeout: Float(ENV.fetch('OTEL_BSP_EXPORT_TIMEOUT', 30_000)),
                          schedule_delay: Float(ENV.fetch('OTEL_BSP_SCHEDULE_DELAY', 5_000)),
                          max_queue_size: Integer(ENV.fetch('OTEL_BSP_MAX_QUEUE_SIZE', 2048)),
@@ -51,6 +52,7 @@ module OpenTelemetry
                          start_thread_on_boot: String(ENV['OTEL_RUBY_BSP_START_THREAD_ON_BOOT']) !~ /false/i,
                          metrics_reporter: nil)
             raise ArgumentError if max_export_batch_size > max_queue_size
+            raise ArgumentError, "exporter #{exporter.inspect} does not appear to be a valid exporter" unless Common::Utilities.valid_exporter?(exporter)
 
             @exporter = exporter
             @exporter_timeout_seconds = exporter_timeout / 1000.0
@@ -99,7 +101,7 @@ module OpenTelemetry
           # @return [Integer] SUCCESS if no error occurred, FAILURE if a
           #   non-specific failure occurred, TIMEOUT if a timeout occurred.
           def force_flush(timeout: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
-            start_time = Time.now
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
             snapshot = lock do
               reset_on_fork if @keep_running
               spans.shift(spans.size)
@@ -113,7 +115,7 @@ module OpenTelemetry
               return result_code unless result_code == SUCCESS
             end
 
-            SUCCESS
+            @exporter.force_flush(timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
           ensure
             # Unshift the remaining spans if we timed out. We drop excess spans from
             # the snapshot because they're older than any spans in the spans buffer.
@@ -135,7 +137,7 @@ module OpenTelemetry
           # @return [Integer] SUCCESS if no error occurred, FAILURE if a
           #   non-specific failure occurred, TIMEOUT if a timeout occurred.
           def shutdown(timeout: nil)
-            start_time = Time.now
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
             thread = lock do
               @keep_running = false
               @condition.signal
@@ -176,6 +178,9 @@ module OpenTelemetry
             @pid = pid
             spans.clear
             @thread = restart_thread ? Thread.new { work } : nil
+          rescue ThreadError => e
+            @metrics_reporter.add_to_counter('otel.bsp.error', labels: { 'reason' => 'ThreadError' })
+            OpenTelemetry.handle_error(exception: e, message: 'unexpected error in BatchSpanProcessor#reset_on_fork')
           end
 
           def export_batch(batch, timeout: @exporter_timeout_seconds)

data/lib/opentelemetry/sdk/trace/export/console_span_exporter.rb

@@ -26,6 +26,10 @@ module OpenTelemetry
             SUCCESS
           end
 
+          def force_flush(timeout: nil)
+            SUCCESS
+          end
+
           def shutdown(timeout: nil)
             @stopped = true
             SUCCESS

data/lib/opentelemetry/sdk/trace/export/in_memory_span_exporter.rb

@@ -10,30 +10,39 @@ module OpenTelemetry
       module Export
         # A SpanExporter implementation that can be used to test OpenTelemetry integration.
         #
-        # Example usage:
+        # Example usage in a test suite:
         #
         # class MyClassTest
         #   def setup
         #     @tracer_provider = TracerProvider.new
-        #     @exporter = InMemorySpanExporter.new
+        #     # The default is `recording: true`, which is appropriate in non-test environments.
+        #     @exporter = InMemorySpanExporter.new(recording: false)
         #     @tracer_provider.add_span_processor(SimpleSampledSpansProcessor.new(@exporter))
         #   end
         #
         #   def test_finished_spans
+        #     @exporter.recording = true
         #     @tracer_provider.tracer.in_span("span") {}
         #
         #     spans = @exporter.finished_spans
         #     spans.wont_be_nil
         #     spans.size.must_equal(1)
         #     spans[0].name.must_equal("span")
+        #
+        #     @exporter.recording = false
         #   end
         class InMemorySpanExporter
+          # Controls whether or not the exporter will record spans, or discard them.
+          # @return [Boolean] when true, the exporter is recording. By default, this is true.
+          attr_accessor :recording
+
           # Returns a new instance of the {InMemorySpanExporter}.
           #
           # @return a new instance of the {InMemorySpanExporter}.
-          def initialize
+          def initialize(recording: true)
             @finished_spans = []
             @stopped = false
+            @recording = recording
             @mutex = Mutex.new
           end
 
@@ -67,11 +76,21 @@ module OpenTelemetry
             @mutex.synchronize do
               return FAILURE if @stopped
 
-              @finished_spans.concat(span_datas.to_a)
+              @finished_spans.concat(span_datas.to_a) if @recording
             end
             SUCCESS
           end
 
+          # Called when {TracerProvider#force_flush} is called, if this exporter is
+          # registered to a {TracerProvider} 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 {TracerProvider#shutdown} is called, if this exporter is
           # registered to a {TracerProvider} object.
           #

data/lib/opentelemetry/sdk/trace/export/multi_span_exporter.rb

@@ -26,7 +26,7 @@ module OpenTelemetry
           # @param [optional Numeric] timeout An optional timeout in seconds.
           # @return [Integer] the result of the export.
           def export(spans, timeout: nil)
-            start_time = Time.now
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
             results = @span_exporters.map do |span_exporter|
               span_exporter.export(spans, timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
             rescue => e # rubocop:disable Style/RescueStandardError
@@ -36,6 +36,23 @@ module OpenTelemetry
             results.uniq.max || SUCCESS
           end
 
+          # Called when {TracerProvider#force_flush} is called, if this exporter is
+          # registered to a {TracerProvider} 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)
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
+            results = @span_exporters.map do |processor|
+              remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
+              return TIMEOUT if remaining_timeout&.zero?
+
+              processor.force_flush(timeout: remaining_timeout)
+            end
+            results.uniq.max || SUCCESS
+          end
+
           # Called when {TracerProvider#shutdown} is called, if this exporter is
           # registered to a {TracerProvider} object.
           #
@@ -43,7 +60,7 @@ module OpenTelemetry
           # @return [Integer] SUCCESS if no error occurred, FAILURE if a
           #   non-specific failure occurred, TIMEOUT if a timeout occurred.
           def shutdown(timeout: nil)
-            start_time = Time.now
+            start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
             results = @span_exporters.map do |processor|
               remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
               return TIMEOUT if remaining_timeout&.zero?

data/lib/opentelemetry/sdk/trace/export/noop_span_exporter.rb

@@ -31,6 +31,16 @@ module OpenTelemetry
             FAILURE
           end
 
+          # Called when {TracerProvider#force_flush} is called, if this exporter is
+          # registered to a {TracerProvider} 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 {TracerProvider#shutdown} is called, if this exporter is
           # registered to a {TracerProvider} object.
           #

data/lib/opentelemetry/sdk/trace/export/simple_span_processor.rb

@@ -29,6 +29,8 @@ module OpenTelemetry
           # @return [SimpleSpanProcessor]
           # @raise ArgumentError if the span_exporter is nil.
           def initialize(span_exporter)
+            raise ArgumentError, "exporter #{span_exporter.inspect} does not appear to be a valid exporter" unless Common::Utilities.valid_exporter?(span_exporter)
+
             @span_exporter = span_exporter
           end
 
@@ -61,7 +63,7 @@ module OpenTelemetry
           end
 
           # Export all ended spans to the configured `Exporter` that have not yet
-          # been exported.
+          # been exported, then call {Exporter#force_flush}.
           #
           # This method should only be called in cases where it is absolutely
           # necessary, such as when using some FaaS providers that may suspend
@@ -72,7 +74,7 @@ module OpenTelemetry
           # @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
+            @span_exporter&.force_flush(timeout: timeout) || SUCCESS
           end
 
           # Called when {TracerProvider#shutdown} is called.

data/lib/opentelemetry/sdk/trace/multi_span_processor.rb

@@ -55,7 +55,7 @@ module OpenTelemetry
         # @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)
-          start_time = Time.now
+          start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
           results = @span_processors.map do |processor|
             remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
             return Export::TIMEOUT if remaining_timeout&.zero?
@@ -71,7 +71,7 @@ module OpenTelemetry
         # @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)
-          start_time = Time.now
+          start_time = OpenTelemetry::Common::Utilities.timeout_timestamp
           results = @span_processors.map do |processor|
             remaining_timeout = OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time)
             return Export::TIMEOUT if remaining_timeout&.zero?

data/lib/opentelemetry/sdk/trace/span.rb

@@ -17,8 +17,9 @@ module OpenTelemetry
       # rubocop:disable Metrics/ClassLength
       class Span < OpenTelemetry::Trace::Span
         DEFAULT_STATUS = OpenTelemetry::Trace::Status.new(OpenTelemetry::Trace::Status::UNSET)
+        EMPTY_ATTRIBUTES = {}.freeze
 
-        private_constant(:DEFAULT_STATUS)
+        private_constant :DEFAULT_STATUS, :EMPTY_ATTRIBUTES
 
         # The following readers are intended for the use of SpanProcessors and
         # should not be considered part of the public interface for instrumentation.
@@ -64,10 +65,12 @@ module OpenTelemetry
         #
         # @param [String] key
         # @param [String, Boolean, Numeric, Array<String, Numeric, Boolean>] value
+        #   Values must be non-nil and (array of) string, boolean or numeric type.
+        #   Array values must not contain nil elements and all elements must be of
+        #   the same basic type (string, numeric, boolean).
         #
         # @return [self] returns itself
         def set_attribute(key, value)
-          super
           @mutex.synchronize do
             if @ended
               OpenTelemetry.logger.warn('Calling set_attribute on an ended Span.')
@@ -82,6 +85,33 @@ module OpenTelemetry
         end
         alias []= set_attribute
 
+        # Add attributes
+        #
+        # Note that the OpenTelemetry project
+        # {https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-semantic-conventions.md
+        # documents} certain "standard attributes" that have prescribed semantic
+        # meanings.
+        #
+        # @param [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}] attributes
+        #   Values must be non-nil and (array of) string, boolean or numeric type.
+        #   Array values must not contain nil elements and all elements must be of
+        #   the same basic type (string, numeric, boolean).
+        #
+        # @return [self] returns itself
+        def add_attributes(attributes)
+          @mutex.synchronize do
+            if @ended
+              OpenTelemetry.logger.warn('Calling add_attributes on an ended Span.')
+            else
+              @attributes ||= {}
+              @attributes.merge!(attributes)
+              trim_span_attributes(@attributes)
+              @total_recorded_attributes += attributes.size
+            end
+          end
+          self
+        end
+
         # Add an Event to a {Span}.
         #
         # Example:
@@ -96,13 +126,12 @@ module OpenTelemetry
         # @param [String] name Name of the event.
         # @param [optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}] attributes
         #   One or more key:value pairs, where the keys must be strings and the
-        #   values may be string, boolean or numeric type.
+        #   values may be (array of) string, boolean or numeric type.
         # @param [optional Time] timestamp Optional timestamp for the event.
         #
         # @return [self] returns itself
         def add_event(name, attributes: nil, timestamp: nil)
-          super
-          event = Event.new(name: name, attributes: attributes, timestamp: timestamp || Time.now)
+          event = Event.new(name, truncate_attribute_values(attributes), wall_clock(timestamp))
 
           @mutex.synchronize do
             if @ended
@@ -148,7 +177,6 @@ module OpenTelemetry
         #
         # @return [void]
         def status=(status)
-          super
           @mutex.synchronize do
             if @ended
               OpenTelemetry.logger.warn('Calling status= on an ended Span.')
@@ -168,7 +196,6 @@ module OpenTelemetry
         #
         # @return [void]
         def name=(new_name)
-          super
           @mutex.synchronize do
             if @ended
               OpenTelemetry.logger.warn('Calling name= on an ended Span.')
@@ -203,7 +230,7 @@ module OpenTelemetry
               OpenTelemetry.logger.warn('Calling finish on an ended Span.')
               return self
             end
-            @end_timestamp = end_timestamp || Time.now
+            @end_timestamp = wall_clock(end_timestamp)
             @attributes = validated_attributes(@attributes).freeze
             @events.freeze
             @ended = true
@@ -261,7 +288,7 @@ module OpenTelemetry
           @total_recorded_events = 0
           @total_recorded_links = links&.size || 0
           @total_recorded_attributes = attributes&.size || 0
-          @start_timestamp = start_timestamp
+          @start_timestamp = wall_clock(start_timestamp)
           @end_timestamp = nil
           @attributes = attributes.nil? ? nil : Hash[attributes] # We need a mutable copy of attributes.
           trim_span_attributes(@attributes)
@@ -275,7 +302,7 @@ module OpenTelemetry
         private
 
         def validated_attributes(attrs)
-          return attrs if Internal.valid_attributes?(attrs)
+          return attrs if Internal.valid_attributes?(name, 'span', attrs)
 
           attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
         end
@@ -285,15 +312,24 @@ module OpenTelemetry
 
           excess = attrs.size - @trace_config.max_attributes_count
           excess.times { attrs.shift } if excess.positive?
+          truncate_attribute_values(attrs)
           nil
         end
 
+        def truncate_attribute_values(attrs)
+          return EMPTY_ATTRIBUTES if attrs.nil?
+
+          max_attributes_length = @trace_config.max_attributes_length
+          attrs.each { |key, value| attrs[key] = OpenTelemetry::Common::Utilities.truncate(value, max_attributes_length) } if max_attributes_length
+          attrs
+        end
+
         def trim_links(links, max_links_count, max_attributes_per_link) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           # Fast path (likely) common cases.
           return nil if links.nil?
 
           if links.size <= max_links_count &&
-             links.all? { |link| link.attributes.size <= max_attributes_per_link && Internal.valid_attributes?(link.attributes) }
+             links.all? { |link| link.attributes.size <= max_attributes_per_link && Internal.valid_attributes?(name, 'link', link.attributes) }
             return links.frozen? ? links : links.clone.freeze
           end
 
@@ -310,7 +346,7 @@ module OpenTelemetry
         def append_event(events, event) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           max_events_count = @trace_config.max_events_count
           max_attributes_per_event = @trace_config.max_attributes_per_event
-          valid_attributes = Internal.valid_attributes?(event.attributes)
+          valid_attributes = Internal.valid_attributes?(name, 'event', event.attributes)
 
           # Fast path (likely) common case.
           if events.size < max_events_count &&
@@ -329,10 +365,15 @@ module OpenTelemetry
             attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
             excess = attrs.size - max_attributes_per_event
             excess.times { attrs.shift } if excess.positive?
-            event = Event.new(name: event.name, attributes: attrs, timestamp: event.timestamp)
+            event = Event.new(event.name, attrs.freeze, event.timestamp)
           end
           events << event
         end
+
+        def wall_clock(timestamp)
+          timestamp = (timestamp.to_r * 1_000_000_000).to_i unless timestamp.nil?
+          timestamp || Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+        end
       end
       # rubocop:enable Metrics/ClassLength
     end