opentelemetry-sdk 0.5.1

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      # The Config module contains the configuration logic for the
+      # OpenTelemetry SDK.
+      module Config
+      end
+    end
+  end
+end
+
+require 'opentelemetry/sdk/trace/config/trace_config'

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Config
+        # Class that holds global trace parameters.
+        class TraceConfig
+          DEFAULT_SAMPLER = Samplers::ALWAYS_ON
+          DEFAULT_MAX_ATTRIBUTES_COUNT = 32
+          DEFAULT_MAX_EVENTS_COUNT = 128
+          DEFAULT_MAX_LINKS_COUNT = 32
+          DEFAULT_MAX_ATTRIBUTES_PER_EVENT = 32
+          DEFAULT_MAX_ATTRIBUTES_PER_LINK = 32
+
+          private_constant(:DEFAULT_SAMPLER,
+                           :DEFAULT_MAX_ATTRIBUTES_COUNT,
+                           :DEFAULT_MAX_EVENTS_COUNT,
+                           :DEFAULT_MAX_LINKS_COUNT,
+                           :DEFAULT_MAX_ATTRIBUTES_PER_EVENT,
+                           :DEFAULT_MAX_ATTRIBUTES_PER_LINK)
+
+          # The global default sampler (see {Samplers}).
+          attr_reader :sampler
+
+          # The global default max number of attributes per {Span}.
+          attr_reader :max_attributes_count
+
+          # The global default max number of {OpenTelemetry::Trace::Event}s per {Span}.
+          attr_reader :max_events_count
+
+          # The global default max number of {OpenTelemetry::Trace::Link} entries per {Span}.
+          attr_reader :max_links_count
+
+          # The global default max number of attributes per {OpenTelemetry::Trace::Event}.
+          attr_reader :max_attributes_per_event
+
+          # The global default max number of attributes per {OpenTelemetry::Trace::Link}.
+          attr_reader :max_attributes_per_link
+
+          # Returns a {TraceConfig} with the desired values.
+          #
+          # @return [TraceConfig] with the desired values.
+          # @raise [ArgumentError] if any of the max numbers are not positive.
+          def initialize(sampler: DEFAULT_SAMPLER,
+                         max_attributes_count: DEFAULT_MAX_ATTRIBUTES_COUNT,
+                         max_events_count: DEFAULT_MAX_EVENTS_COUNT,
+                         max_links_count: DEFAULT_MAX_LINKS_COUNT,
+                         max_attributes_per_event: DEFAULT_MAX_ATTRIBUTES_PER_EVENT,
+                         max_attributes_per_link: DEFAULT_MAX_ATTRIBUTES_PER_LINK)
+            raise ArgumentError, 'max_attributes_count must be positive' unless max_attributes_count.positive?
+            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?
+            raise ArgumentError, 'max_attributes_per_link must be positive' unless max_attributes_per_link.positive?
+
+            @sampler = sampler
+            @max_attributes_count = max_attributes_count
+            @max_events_count = max_events_count
+            @max_links_count = max_links_count
+            @max_attributes_per_event = max_attributes_per_event
+            @max_attributes_per_link = max_attributes_per_link
+          end
+
+          # TODO: from_proto
+
+          # The default {TraceConfig}.
+          DEFAULT = new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      # The Export module contains the built-in exporters for the OpenTelemetry
+      # reference implementation.
+      module Export
+        # Result codes for the SpanExporter#export method.
+
+        # The export operation finished successfully.
+        SUCCESS = 0
+
+        # The export operation finished with an error.
+        FAILURE = 1
+      end
+    end
+  end
+end
+
+require 'opentelemetry/sdk/trace/export/batch_span_processor'
+require 'opentelemetry/sdk/trace/export/console_span_exporter'
+require 'opentelemetry/sdk/trace/export/in_memory_span_exporter'
+require 'opentelemetry/sdk/trace/export/multi_span_exporter'
+require 'opentelemetry/sdk/trace/export/noop_span_exporter'
+require 'opentelemetry/sdk/trace/export/simple_span_processor'

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

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'timeout'
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Export
+        # Implementation of the duck type SpanProcessor that batches spans
+        # exported by the SDK then pushes them to the exporter pipeline.
+        #
+        # All spans reported by the SDK implementation are first added to a
+        # synchronized queue (with a {max_queue_size} maximum size, after the
+        # size is reached spans are dropped) and exported every
+        # schedule_delay_millis to the exporter pipeline in batches of
+        # max_export_batch_size.
+        #
+        # If the queue gets half full a preemptive notification is sent to the
+        # worker thread that exports the spans to wake up and start a new
+        # export cycle.
+        class BatchSpanProcessor
+          EXPORTER_TIMEOUT_MILLIS = 30_000
+          SCHEDULE_DELAY_MILLIS = 5_000
+          MAX_QUEUE_SIZE = 2048
+          MAX_EXPORT_BATCH_SIZE = 512
+          private_constant(:SCHEDULE_DELAY_MILLIS, :MAX_QUEUE_SIZE, :MAX_EXPORT_BATCH_SIZE)
+
+          def initialize(exporter:,
+                         exporter_timeout_millis: EXPORTER_TIMEOUT_MILLIS,
+                         schedule_delay_millis: SCHEDULE_DELAY_MILLIS,
+                         max_queue_size: MAX_QUEUE_SIZE,
+                         max_export_batch_size: MAX_EXPORT_BATCH_SIZE)
+            raise ArgumentError if max_export_batch_size > max_queue_size
+
+            @exporter = exporter
+            @exporter_timeout_seconds = exporter_timeout_millis / 1000.0
+            @mutex = Mutex.new
+            @condition = ConditionVariable.new
+            @keep_running = true
+            @delay_seconds = schedule_delay_millis / 1000.0
+            @max_queue_size = max_queue_size
+            @batch_size = max_export_batch_size
+            @spans = []
+            @thread = Thread.new { work }
+          end
+
+          # does nothing for this processor
+          def on_start(span)
+            # noop
+          end
+
+          # adds a span to the batcher, threadsafe may block on lock
+          def on_finish(span) # rubocop:disable Metrics/AbcSize
+            return unless span.context.trace_flags.sampled?
+
+            lock do
+              n = spans.size + 1 - max_queue_size
+              spans.shift(n) if n.positive?
+              spans << span
+              @condition.signal if spans.size > max_queue_size / 2
+            end
+          end
+
+          # TODO: test this explicitly.
+          # Export all ended spans 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.
+          def force_flush
+            snapshot = lock { spans.shift(spans.size) }
+            until snapshot.empty?
+              batch = snapshot.shift(@batch_size).map!(&:to_span_data)
+              result_code = @exporter.export(batch)
+              report_result(result_code, batch)
+            end
+          end
+
+          # shuts the consumer thread down and flushes the current accumulated buffer
+          # will block until the thread is finished
+          def shutdown
+            lock do
+              @keep_running = false
+              @condition.signal
+            end
+
+            @thread.join
+            force_flush
+            @exporter.shutdown
+          end
+
+          private
+
+          attr_reader :spans, :max_queue_size, :batch_size
+
+          def work
+            loop do
+              batch = lock do
+                @condition.wait(@mutex, @delay_seconds) if spans.size < batch_size && @keep_running
+                @condition.wait(@mutex, @delay_seconds) while spans.empty? && @keep_running
+                return unless @keep_running
+
+                fetch_batch
+              end
+
+              export_batch(batch)
+            end
+          end
+
+          def export_batch(batch)
+            result_code = export_with_timeout(batch)
+            report_result(result_code, batch)
+          end
+
+          def export_with_timeout(batch)
+            Timeout.timeout(@exporter_timeout_seconds) { @exporter.export(batch) }
+          rescue Timeout::Error
+            FAILURE
+          end
+
+          def report_result(result_code, batch)
+            OpenTelemetry.logger.error("Unable to export #{batch.size} spans") unless result_code == SUCCESS
+          end
+
+          def fetch_batch
+            spans.shift(@batch_size).map!(&:to_span_data)
+          end
+
+          def lock
+            @mutex.synchronize do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'pp'
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Export
+        # Outputs {SpanData} to the console.
+        #
+        # Potentially useful for exploratory purposes.
+        class ConsoleSpanExporter
+          ResultCodes = OpenTelemetry::SDK::Trace::Export
+
+          private_constant(:ResultCodes)
+
+          def initialize
+            @stopped = false
+          end
+
+          def export(spans)
+            return ResultCodes::FAILURE if @stopped
+
+            Array(spans).each { |s| pp s }
+
+            ResultCodes::SUCCESS
+          end
+
+          def shutdown
+            @stopped = true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Export
+        # A SpanExporter implementation that can be used to test OpenTelemetry integration.
+        #
+        # Example usage:
+        #
+        # class MyClassTest
+        #   def setup
+        #     @tracer_provider = TracerProvider.new
+        #     @exporter = InMemorySpanExporter.new
+        #     @tracer_provider.add_span_processor(SimpleSampledSpansProcessor.new(@exporter))
+        #   end
+        #
+        #   def test_finished_spans
+        #     @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")
+        #   end
+        class InMemorySpanExporter
+          # Returns a new instance of the {InMemorySpanExporter}.
+          #
+          # @return a new instance of the {InMemorySpanExporter}.
+          def initialize
+            @finished_spans = []
+            @stopped = false
+            @mutex = Mutex.new
+          end
+
+          # Returns a frozen array of the finished {SpanData}s, represented by
+          # {io.opentelemetry.proto.trace.v1.Span}.
+          #
+          # @return [Array<SpanData>] a frozen array of the finished {SpanData}s.
+          def finished_spans
+            @mutex.synchronize do
+              @finished_spans.clone.freeze
+            end
+          end
+
+          # Clears the internal collection of finished {Span}s.
+          #
+          # Does not reset the state of this exporter if already shutdown.
+          def reset
+            @mutex.synchronize do
+              @finished_spans.clear
+            end
+          end
+
+          # Called to export sampled {SpanData}s.
+          #
+          # @param [Enumerable<SpanData>] span_datas the list of sampled {SpanData}s to be
+          #   exported.
+          # @return [Integer] the result of the export, SUCCESS or
+          #   FAILURE
+          def export(span_datas)
+            @mutex.synchronize do
+              return FAILURE if @stopped
+
+              @finished_spans.concat(span_datas.to_a)
+            end
+            SUCCESS
+          end
+
+          # Called when {TracerProvider#shutdown} is called, if this exporter is
+          # registered to a {TracerProvider} object.
+          def shutdown
+            @mutex.synchronize do
+              @finished_spans.clear
+              @stopped = true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Export
+        # Implementation of the SpanExporter duck type that simply forwards all
+        # received spans to a collection of SpanExporters.
+        #
+        # Can be used to export to multiple backends using the same
+        # SpanProcessor like a {SimpleSpanProcessor} or a
+        # {BatchSpanProcessor}.
+        class MultiSpanExporter
+          def initialize(span_exporters)
+            @span_exporters = span_exporters.clone.freeze
+          end
+
+          # Called to export sampled {Span}s.
+          #
+          # @param [Enumerable<Span>] spans the list of sampled {Span}s to be
+          #   exported.
+          # @return [Integer] the result of the export.
+          def export(spans)
+            @span_exporters.inject(SUCCESS) do |result_code, span_exporter|
+              merge_result_code(result_code, span_exporter.export(spans))
+            rescue => e # rubocop:disable Style/RescueStandardError
+              OpenTelemetry.logger.warn("exception raised by export - #{e}")
+              FAILURE
+            end
+          end
+
+          # Called when {TracerProvider#shutdown} is called, if this exporter is
+          # registered to a {TracerProvider} object.
+          def shutdown
+            @span_exporters.each(&:shutdown)
+          end
+
+          private
+
+          # Returns a merged error code, see the rules in the code.
+          def merge_result_code(result_code, new_result_code)
+            if result_code == SUCCESS && new_result_code == SUCCESS
+              # If both errors are success then return success.
+              SUCCESS
+            else
+              # At this point at least one of the code is FAILURE, so return FAILURE.
+              FAILURE
+            end
+          end
+        end
+      end
+    end
+  end
+end