opentelemetry-sdk 0.13.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b64da58e8086f08efd2f7bace98369ec16936abcf95996588bda288a592d5912
-  data.tar.gz: 4d67cd982c51998cf0396531bcbaae6f62f23b89314793def72410624c87a645
+  metadata.gz: 4be88dba1f3a925ceb97494267f2d27cfb24f5f89e417236d5cca698c0388b9b
+  data.tar.gz: 8e43a87d87dc739c1323acecaa18e93dac8a911fc28a119c016e5e834ca74615
 SHA512:
-  metadata.gz: 3d8d0331a351e32cf184a512c155c6d3944bb5bbbb2857aad27636bdc7eca58081d45e6d778eecd50681e1a1c471c75f9cf7d8116b57ba5c5c5b7a5838f3a648
-  data.tar.gz: ef884f72a85e1457b1d160d2075313df169f895cfe92831d87e77022244db6b6d980f7a36f6c88926886fd67538e916c2e813728ce80aa2897ef24da216d2924
+  metadata.gz: 672426fc31d0c6cce4f363509085b40bddf66d6c6516048e40ae1661fefaf2a6a3482acfe9a6dcff8db328675fb2e5ec02c9fe89d91486f551bf029bcb390f6b
+  data.tar.gz: 42b693687ddfdf1221c972d902e9249fcec6a947bb48416b4627fbd805859ac8bc5fcdb18ac44e4fb628bfd56f67bf42d028465f6e34c4c679844a7c1027515d

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Release History: opentelemetry-sdk
 
+### v0.17.0 / 2021-04-22
+
+* BREAKING CHANGE: Replace TextMapInjector/TextMapExtractor pairs with a TextMapPropagator.
+
+  [Check the propagator documentation](https://open-telemetry.github.io/opentelemetry-ruby/) for the new usage.
+
+* ADDED: Add zipkin exporter 
+* ADDED: Processors validate exporters on init. 
+* ADDED: Add configurable truncation of span and event attribute values  
+* ADDED: Add simple 'recording' attr_accessor to InMemorySpanExporter 
+* FIXED: Typo in error message 
+* FIXED: Improve configuration error reporting 
+* FIXED: Refactor propagators to add #fields 
+
+### v0.16.0 / 2021-03-17
+
+* BREAKING CHANGE: Update SDK BaggageManager to match API 
+* BREAKING CHANGE: Implement Exporter#force_flush 
+
+* ADDED: Add force_flush to SDK's TracerProvider 
+* ADDED: Add k8s node to gcp resource detector 
+* ADDED: Add console option for OTEL_TRACES_EXPORTER 
+* ADDED: Span#add_attributes 
+* ADDED: Implement Exporter#force_flush 
+* FIXED: Update SDK BaggageManager to match API 
+* DOCS: Replace Gitter with GitHub Discussions 
+
+### v0.15.0 / 2021-02-18
+
+* BREAKING CHANGE: Streamline processor pipeline 
+
+* ADDED: Add instrumentation config validation 
+* FIXED: Streamline processor pipeline 
+* FIXED: OTEL_TRACE -> OTEL_TRACES env vars 
+* FIXED: Change limits from 1000 to 128 
+* FIXED: OTEL_TRACES_EXPORTER and OTEL_PROPAGATORS 
+* FIXED: Add thread error handling to the BSP 
+* DOCS: Clarify nil attribute values not allowed 
+
+### v0.14.0 / 2021-02-03
+
+* BREAKING CHANGE: Replace getter and setter callables and remove rack specific propagators 
+
+* ADDED: Replace getter and setter callables and remove rack specific propagators 
+
+### v0.13.1 / 2021-02-01
+
+* FIXED: Leaky test 
+* FIXED: Allow env var override of service.name 
+
 ### v0.13.0 / 2021-01-29
 
 * BREAKING CHANGE: Remove MILLIS from BatchSpanProcessor vars 

data/README.md

@@ -56,7 +56,7 @@ For additional examples, see the [examples on github][examples-github].
 
 The `opentelemetry-sdk` gem source is [on github][repo-github], along with related gems including `opentelemetry-api`.
 
-The OpenTelemetry Ruby gems are maintained by the OpenTelemetry-Ruby special interest group (SIG). You can get involved by joining us on our [gitter channel][ruby-gitter] or attending our weekly meeting. See the [meeting calendar][community-meetings] for dates and times. For more information on this and other language SIGs, see the OpenTelemetry [community page][ruby-sig].
+The OpenTelemetry Ruby gems are maintained by the OpenTelemetry-Ruby special interest group (SIG). You can get involved by joining us in [GitHub Discussions][discussions-url] or attending our weekly meeting. See the [meeting calendar][community-meetings] for dates and times. For more information on this and other language SIGs, see the OpenTelemetry [community page][ruby-sig].
 
 ## License
 
@@ -70,4 +70,4 @@ The `opentelemetry-sdk` gem is distributed under the Apache 2.0 license. See [LI
 [examples-github]: https://github.com/open-telemetry/opentelemetry-ruby/tree/main/examples
 [ruby-sig]: https://github.com/open-telemetry/community#ruby-sig
 [community-meetings]: https://github.com/open-telemetry/community#community-meetings
-[ruby-gitter]: https://gitter.im/open-telemetry/opentelemetry-ruby
+[discussions-url]: https://github.com/open-telemetry/opentelemetry-ruby/discussions

data/lib/opentelemetry/sdk.rb

@@ -6,6 +6,7 @@
 
 require 'opentelemetry'
 require 'opentelemetry/common'
+require 'opentelemetry-instrumentation-base'
 
 # OpenTelemetry is an open source observability framework, providing a
 # general-purpose API, SDK, and related tools required for the instrumentation
@@ -66,14 +67,13 @@ module OpenTelemetry
       begin
         raise ConfigurationError
       rescue ConfigurationError => e
-        OpenTelemetry.handle_error(exception: e, message: 'unexpected configuration error')
+        OpenTelemetry.handle_error(exception: e, message: "unexpected configuration error due to #{e.cause}")
       end
     end
   end
 end
 
 require 'opentelemetry/sdk/configurator'
-require 'opentelemetry/sdk/baggage'
 require 'opentelemetry/sdk/internal'
 require 'opentelemetry/sdk/instrumentation_library'
 require 'opentelemetry/sdk/resources'

data/lib/opentelemetry/sdk/configurator.rb

@@ -15,16 +15,12 @@ module OpenTelemetry
 
       private_constant :USE_MODE_UNSPECIFIED, :USE_MODE_ONE, :USE_MODE_ALL
 
-      attr_writer :logger, :http_extractors, :http_injectors, :text_map_extractors,
-                  :text_map_injectors, :error_handler, :id_generator
+      attr_writer :logger, :propagators, :error_handler, :id_generator
 
       def initialize
         @instrumentation_names = []
         @instrumentation_config_map = {}
-        @http_extractors = nil
-        @http_injectors = nil
-        @text_map_extractors = nil
-        @text_map_injectors = nil
+        @propagators = nil
         @span_processors = []
         @use_mode = USE_MODE_UNSPECIFIED
         @resource = Resources::Resource.default
@@ -138,61 +134,61 @@ module OpenTelemetry
       def install_instrumentation
         case @use_mode
         when USE_MODE_ONE
-          OpenTelemetry.instrumentation_registry.install(@instrumentation_names, @instrumentation_config_map)
+          OpenTelemetry::Instrumentation.registry.install(@instrumentation_names, @instrumentation_config_map)
         when USE_MODE_ALL
-          OpenTelemetry.instrumentation_registry.install_all(@instrumentation_config_map)
+          OpenTelemetry::Instrumentation.registry.install_all(@instrumentation_config_map)
         end
       end
 
       def configure_span_processors
-        processors = @span_processors.empty? ? [default_span_processor] : @span_processors
+        processors = @span_processors.empty? ? [wrapped_exporter_from_env].compact : @span_processors
         processors.each { |p| tracer_provider.add_span_processor(p) }
       end
 
-      def default_span_processor
-        Trace::Export::SimpleSpanProcessor.new(
-          Trace::Export::ConsoleSpanExporter.new
-        )
-      end
-
-      def configure_propagation
-        OpenTelemetry.propagation.http = create_propagator(@http_injectors || default_http_injectors,
-                                                           @http_extractors || default_http_extractors)
-        OpenTelemetry.propagation.text = create_propagator(@text_map_injectors || default_text_map_injectors,
-                                                           @text_map_extractors || default_text_map_extractors)
-      end
-
-      def create_propagator(injectors, extractors)
-        if injectors.size > 1 || extractors.size > 1
-          Context::Propagation::CompositePropagator.new(injectors, extractors)
+      def wrapped_exporter_from_env
+        exporter = ENV.fetch('OTEL_TRACES_EXPORTER', 'otlp')
+        case exporter
+        when 'none' then nil
+        when 'otlp' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::OTLP::Exporter')
+        when 'jaeger' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::Jaeger::CollectorExporter')
+        when 'zipkin' then fetch_exporter(exporter, 'OpenTelemetry::Exporter::Zipkin::Exporter')
+        when 'console' then Trace::Export::SimpleSpanProcessor.new(Trace::Export::ConsoleSpanExporter.new)
         else
-          Context::Propagation::Propagator.new(injectors, extractors)
+          OpenTelemetry.logger.warn "The #{exporter} exporter is unknown and cannot be configured, spans will not be exported"
+          nil
         end
       end
 
-      def default_http_injectors
-        default_text_map_injectors
-      end
-
-      def default_http_extractors
-        [
-          OpenTelemetry::Trace::Propagation::TraceContext.rack_extractor,
-          OpenTelemetry::Baggage::Propagation.rack_extractor
-        ]
+      def configure_propagation # rubocop:disable Metrics/CyclomaticComplexity
+        propagators = ENV.fetch('OTEL_PROPAGATORS', 'tracecontext,baggage').split(',').uniq.collect do |propagator|
+          case propagator
+          when 'tracecontext' then OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator
+          when 'baggage' then OpenTelemetry::Baggage::Propagation.text_map_propagator
+          when 'b3' then fetch_propagator(propagator, 'OpenTelemetry::Propagator::B3::Single')
+          when 'b3multi' then fetch_propagator(propagator, 'OpenTelemetry::Propagator::B3::Multi', 'b3')
+          when 'jaeger' then fetch_propagator(propagator, 'OpenTelemetry::Propagator::Jaeger')
+          when 'xray' then fetch_propagator(propagator, 'OpenTelemetry::Propagator::XRay')
+          when 'ottrace' then fetch_propagator(propagator, 'OpenTelemetry::Propagator::OTTrace')
+          else
+            OpenTelemetry.logger.warn "The #{propagator} propagator is unknown and cannot be configured"
+            Context::Propagation::NoopTextMapPropagator.new
+          end
+        end
+        OpenTelemetry.propagation = Context::Propagation::CompositeTextMapPropagator.compose_propagators((@propagators || propagators).compact)
       end
 
-      def default_text_map_injectors
-        [
-          OpenTelemetry::Trace::Propagation::TraceContext.text_map_injector,
-          OpenTelemetry::Baggage::Propagation.text_map_injector
-        ]
+      def fetch_propagator(name, class_name, gem_suffix = name)
+        Kernel.const_get(class_name).text_map_propagator
+      rescue NameError
+        OpenTelemetry.logger.warn "The #{name} propagator cannot be configured - please add opentelemetry-propagator-#{gem_suffix} to your Gemfile"
+        nil
       end
 
-      def default_text_map_extractors
-        [
-          OpenTelemetry::Trace::Propagation::TraceContext.text_map_extractor,
-          OpenTelemetry::Baggage::Propagation.text_map_extractor
-        ]
+      def fetch_exporter(name, class_name)
+        Trace::Export::BatchSpanProcessor.new(Kernel.const_get(class_name).new)
+      rescue NameError
+        OpenTelemetry.logger.warn "The #{name} exporter cannot be configured - please add opentelemetry-exporter-#{name} to your Gemfile, spans will not be exported"
+        nil
       end
     end
   end

data/lib/opentelemetry/sdk/internal.rb

@@ -47,7 +47,7 @@ module OpenTelemetry
       def valid_attributes?(attrs)
         attrs.nil? || attrs.all? do |k, v|
           if !valid_key?(k)
-            OpenTelemetry.handle_error(message: "invalid attribute key type #{v.class}")
+            OpenTelemetry.handle_error(message: "invalid attribute key type #{k.class}")
             false
           elsif !valid_value?(v)
             OpenTelemetry.handle_error(message: "invalid attribute value type #{v.class}")

data/lib/opentelemetry/sdk/resources/constants.rb

@@ -67,14 +67,59 @@ module OpenTelemetry
           # The name of the cluster that the pod is running in.
           cluster_name: 'k8s.cluster.name',
 
+          # The name of the Node.
+          node_name: 'k8s.node.name',
+
+          # The UID of the Node.
+          node_uid: 'k8s.node.uid',
+
           # The name of the namespace that the pod is running in.
           namespace_name: 'k8s.namespace.name',
 
           # The name of the pod.
           pod_name: 'k8s.pod.name',
 
+          # The UID of the Pod.
+          pod_uid: 'k8s.pod.uid',
+
+          #  The name of the Container in a Pod template.
+          container_name: 'k8s.container.name',
+
+          # The UID of the ReplicaSet.
+          replicaset_uid: 'k8s.replicaset.uid',
+
+          # The name of the ReplicaSet.
+          replicaset_name: 'k8s.replicaset.name',
+
+          # The UID of the Deployment.
+          deployment_uid: 'k8s.deployment.uid',
+
           # The name of the deployment.
-          deployment_name: 'k8s.deployment.name'
+          deployment_name: 'k8s.deployment.name',
+
+          # The UID of the StatefulSet.
+          statefulset_uid: 'k8s.statefulset.uid',
+
+          # The name of the StatefulSet.
+          statefulset_name: 'k8s.statefulset.name',
+
+          # The UID of the DaemonSet.
+          daemonset_uid: 'k8s.daemonset.uid',
+
+          # The name of the DaemonSet.
+          daemonset_name: 'k8s.daemonset.name',
+
+          # The UID of the Job.
+          job_uid: 'k8s.job.uid',
+
+          # The name of the Job.
+          job_name: 'k8s.job.name',
+
+          # The UID of the CronJob.
+          cronjob_uid: 'k8s.cronjob.uid',
+
+          # The name of the CronJob.
+          cronjob_name: 'k8s.cronjob.name'
         }.freeze
 
         # Attributes defining an operating system process.

data/lib/opentelemetry/sdk/resources/resource.rb

@@ -31,7 +31,7 @@ module OpenTelemetry
           end
 
           def default
-            @default ||= telemetry_sdk.merge(process).merge(create(Constants::SERVICE_RESOURCE[:name] => 'unknown_service'))
+            @default ||= create(Constants::SERVICE_RESOURCE[:name] => 'unknown_service').merge(process).merge(telemetry_sdk)
           end
 
           def telemetry_sdk

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/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
@@ -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.
@@ -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

@@ -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 = Time.now
+            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.
           #

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/span.rb

@@ -64,6 +64,9 @@ 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)
@@ -82,6 +85,34 @@ 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)
+          super
+          @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 +127,13 @@ 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: name, attributes: truncate_attribute_values(attributes), timestamp: timestamp || Time.now)
 
           @mutex.synchronize do
             if @ended
@@ -285,9 +316,18 @@ 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 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?

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

@@ -42,7 +42,7 @@ module OpenTelemetry
           @mutex.synchronize { @registry[Key.new(name, version)] ||= Tracer.new(name, version, self) }
         end
 
-        # Attempts to stop all the activity for this {Tracer}. Calls
+        # Attempts to stop all the activity for this {TracerProvider}. Calls
         # SpanProcessor#shutdown for all registered SpanProcessors.
         #
         # This operation may block until all the Spans are processed. Must be
@@ -63,12 +63,26 @@ module OpenTelemetry
           end
         end
 
-        # Adds a new SpanProcessor to this {Tracer}.
+        # Immediately export all spans that have not yet been exported for all the
+        # registered SpanProcessors.
+        #
+        # 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.
         #
-        # Any registered processor causes overhead, consider to use an
-        # async/batch processor especially for span exporting, and export to
-        # multiple backends using the
-        # {io.opentelemetry.sdk.trace.export.MultiSpanExporter}.
+        # @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
+
+            @active_span_processor.force_flush(timeout: timeout)
+          end
+        end
+
+        # Adds a new SpanProcessor to this {Tracer}.
         #
         # @param span_processor the new SpanProcessor to be added.
         def add_span_processor(span_processor)
@@ -78,7 +92,11 @@ module OpenTelemetry
               return
             end
             @registered_span_processors << span_processor
-            @active_span_processor = MultiSpanProcessor.new(@registered_span_processors.dup)
+            @active_span_processor = if @registered_span_processors.size == 1
+                                       span_processor
+                                     else
+                                       MultiSpanProcessor.new(@registered_span_processors.dup)
+                                     end
           end
         end
       end

data/lib/opentelemetry/sdk/version.rb

@@ -7,6 +7,6 @@
 module OpenTelemetry
   module SDK
     ## Current OpenTelemetry version
-    VERSION = '0.13.0'
+    VERSION = '0.17.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-sdk
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.17.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-30 00:00:00.000000000 Z
+date: 2021-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -16,28 +16,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.17.0
 - !ruby/object:Gem::Dependency
   name: opentelemetry-common
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.17.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-base
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-jaeger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -163,9 +191,6 @@ files:
 - README.md
 - lib/opentelemetry-sdk.rb
 - lib/opentelemetry/sdk.rb
-- lib/opentelemetry/sdk/baggage.rb
-- lib/opentelemetry/sdk/baggage/builder.rb
-- lib/opentelemetry/sdk/baggage/manager.rb
 - lib/opentelemetry/sdk/configurator.rb
 - lib/opentelemetry/sdk/instrumentation_library.rb
 - lib/opentelemetry/sdk/internal.rb
@@ -201,10 +226,10 @@ homepage: https://github.com/open-telemetry/opentelemetry-ruby
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v0.13.0/file.CHANGELOG.html
+  changelog_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v0.17.0/file.CHANGELOG.html
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby/tree/main/sdk
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby/issues
-  documentation_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v0.13.0
+  documentation_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v0.17.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -220,7 +245,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A stats collection and distributed tracing framework

data/lib/opentelemetry/sdk/baggage.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-require 'opentelemetry/sdk/baggage/builder'
-require 'opentelemetry/sdk/baggage/manager'
-
-module OpenTelemetry
-  module SDK
-    # Contains operational implementations of the Baggage::Manager
-    module Baggage
-    end
-  end
-end

data/lib/opentelemetry/sdk/baggage/builder.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Baggage
-      # SDK implementation of Baggage::Builder
-      class Builder
-        attr_reader :entries
-
-        def initialize(entries)
-          @entries = entries
-        end
-
-        # Set key-value in the to-be-created baggage
-        #
-        # @param [String] key The key to store this value under
-        # @param [String] value String value to be stored under key
-        def set_value(key, value)
-          @entries[key] = value.to_s
-        end
-
-        # Removes key from the to-be-created baggage
-        #
-        # @param [String] key The key to remove
-        def remove_value(key)
-          @entries.delete(key)
-        end
-
-        # Clears all baggage from the to-be-created baggage
-        def clear
-          @entries.clear
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/sdk/baggage/manager.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Baggage
-      # Manages baggage
-      class Manager
-        BAGGAGE_KEY = OpenTelemetry::Baggage::Propagation::ContextKeys.baggage_key
-        EMPTY_BAGGAGE = {}.freeze
-        private_constant(:BAGGAGE_KEY, :EMPTY_BAGGAGE)
-
-        # Used to chain modifications to baggage. The result is a
-        # context with an updated baggage. If only a single
-        # modification is being made to baggage, use the other
-        # methods on +Manager+, if multiple modifications are being made, use
-        # this one.
-        #
-        # @param [optional Context] context The context to update with with new
-        #   modified baggage. Defaults to +Context.current+
-        # @return [Context]
-        def build_context(context: Context.current)
-          builder = Builder.new(baggage_for(context).dup)
-          yield builder
-          context.set_value(BAGGAGE_KEY, builder.entries)
-        end
-
-        # Returns a new context with empty baggage
-        #
-        # @param [optional Context] context Context to clear baggage from. Defaults
-        #   to +Context.current+
-        # @return [Context]
-        def clear(context: Context.current)
-          context.set_value(BAGGAGE_KEY, EMPTY_BAGGAGE)
-        end
-
-        # Returns the corresponding baggage value (or nil) for key
-        #
-        # @param [String] key The lookup key
-        # @param [optional Context] context The context from which to retrieve
-        #   the key.
-        #   Defaults to +Context.current+
-        # @return [String]
-        def value(key, context: Context.current)
-          baggage_for(context)[key]
-        end
-
-        # Returns the baggage
-        #
-        # @param [optional Context] context The context from which to retrieve
-        #   the baggage.
-        #   Defaults to +Context.current+
-        # @return [Hash]
-        def values(context: Context.current)
-          baggage_for(context).dup.freeze
-        end
-
-        # Returns a new context with new key-value pair
-        #
-        # @param [String] key The key to store this value under
-        # @param [String] value String value to be stored under key
-        # @param [optional Context] context The context to update with new
-        #   value. Defaults to +Context.current+
-        # @return [Context]
-        def set_value(key, value, context: Context.current)
-          new_baggage = baggage_for(context).dup
-          new_baggage[key] = value
-          context.set_value(BAGGAGE_KEY, new_baggage)
-        end
-
-        # Returns a new context with value at key removed
-        #
-        # @param [String] key The key to remove
-        # @param [optional Context] context The context to remove baggage
-        #   from. Defaults to +Context.current+
-        # @return [Context]
-        def remove_value(key, context: Context.current)
-          baggage = baggage_for(context)
-          return context unless baggage.key?(key)
-
-          new_baggage = baggage.dup
-          new_baggage.delete(key)
-          context.set_value(BAGGAGE_KEY, new_baggage)
-        end
-
-        private
-
-        def baggage_for(context)
-          context.value(BAGGAGE_KEY) || EMPTY_BAGGAGE
-        end
-      end
-    end
-  end
-end