opentelemetry-sdk 1.0.0.rc2 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d43559eaa2be64a3597d078d032c168429702e47bdeaee1ac454dc5e74f9f496
-  data.tar.gz: 583f42bb1b6543d6375d3cfc8e4bd2319d5146306f42a73d726ca73f3c01e56d
+  metadata.gz: 7bdebb54966352742da13ac2700b592e49a9f06a751961f7e9d41e70cf855c29
+  data.tar.gz: 4a977ef6391a6c76b6c333797abab87aba952ee357541b482b72441156c4a7fc
 SHA512:
-  metadata.gz: 14112a30284f0ececabcf75dda91f6634b3748c44ccec52e19c6d42e7fae59979e6ea82ef276d21ea5503d2b4f35821945b62d2b1afc83c5bcb9d4a6a9ce6bf4
-  data.tar.gz: 87aaa08db88b9495c86ee1135cdcbfb95827fbbed42edf3280500d86025ff269ee3af95c675e20231267e7b561082cea12df7738db004922468246ad437805fb
+  metadata.gz: 8c54d7a07907e48fcef2e9bcab362ca15e8f86d290daa9e88fc2118135004e734fb136998d7f4f46ac419e3a193775dd9ad5fb572fb170d71bd909c9f01a419b
+  data.tar.gz: be5d9d93ae1f824a250f8dbea0ca63d5318c1d109bc3d83a9a7d237305a2de899c102dd144eb9f03ecb6f653af7415616deecbf609ca30fba7a9941532d88d2a

data/CHANGELOG.md

@@ -1,5 +1,49 @@
 # Release History: opentelemetry-sdk
 
+### v1.0.2 / 2021-12-01
+
+* FIXED: Default span kind 
+* FIXED: Use monotonic clock where possible 
+
+### v1.0.1 / 2021-10-29
+
+* FIXED: Add unexpected error handlign in BSP and OTLP exporter (#995)
+
+### v1.0.0 / 2021-09-29
+
+* (No significant changes)
+
+### v1.0.0.rc3 / 2021-08-12
+
+* BREAKING CHANGE: Remove optional parent_context from in_span
+* BREAKING CHANGE: Replace Time.now with Process.clock_gettime
+* BREAKING CHANGE: Refactor Baggage to remove Noop*
+* BREAKING CHANGE: Remove unnecessary readers from SDK Tracer
+* BREAKING CHANGE: Total order constraint on span.status=
+* BREAKING CHANGE: Use auto-generated resource constants in sdk and resource_detectors
+* BREAKING CHANGE: Span limits env vars
+
+* ADDED: Add Tracer.non_recording_span to API
+* ADDED: Add unnamed tracer warning message
+* ADDED: Allow disabling of install messages
+* ADDED: Make API's NoopTextMapPropagator private
+* ADDED: Use auto-generated resource constants in sdk and resource_detectors
+* ADDED: Allow selecting multiple exporter
+* ADDED: Add explicit BSP export error
+* FIXED: Remove optional parent_context from in_span
+* FIXED: Replace Time.now with Process.clock_gettime
+* FIXED: Rename cloud.zone to cloud.availability_zone
+* FIXED: Improve attribute error messages
+* FIXED: Refactor Baggage to remove Noop*
+* FIXED: Support OTEL_SERVICE_NAME env var
+* FIXED: Remove unnecessary readers from SDK Tracer
+* FIXED: Total order constraint on span.status=
+* FIXED: Flakey tracer provider test
+* FIXED: Split lock in TracerProvider
+* FIXED: Span limits env vars
+* FIXED: Prune invalid links
+* DOCS: Update docs to rely more on environment variable configuration
+
 ### v1.0.0.rc2 / 2021-06-23
 
 * BREAKING CHANGE: Remove optional parent_context from in_span [729](https://github.com/open-telemetry/opentelemetry-ruby/pull/729)

data/README.md

@@ -29,10 +29,33 @@ Then, configure the SDK according to your desired handling of telemetry data, an
 ```ruby
 require 'opentelemetry/sdk'
 
-# Configure the sdk with default export and context propagation formats
-# see SDK#configure for customizing the setup
+# Configure the sdk with default export and context propagation formats.
 OpenTelemetry::SDK.configure
 
+# Many configuration options may be set via the environment. To use them,
+# set the appropriate variable before calling configure. For example:
+#
+# ENV['OTEL_TRACES_EXPORTER'] = 'console'
+# ENV['OTEL_PROPAGATORS'] = 'ottrace'
+# OpenTelemetry::SDK.configure
+#
+# You may also configure the SDK programmatically, for advanced usage or to
+# enable auto-instrumentation. For example:
+#
+# OpenTelemetry::SDK.configure do |c|
+#   c.service_name = something_calculated_dynamically
+#   c.add_span_processor(
+#     OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(
+#       OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
+#     )
+#   )
+#
+#   c.use 'OpenTelemetry::Instrumentation::Net::HTTP'
+# end
+#
+# Note that the SimpleSpanExporter is not recommended for use in production.
+
+
 # To start a trace you need to get a Tracer from the TracerProvider
 tracer = OpenTelemetry.tracer_provider.tracer('my_app_or_gem', '0.1.0')
 

data/lib/opentelemetry/sdk/configurator.rb

@@ -9,6 +9,22 @@ module OpenTelemetry
     # The configurator provides defaults and facilitates configuring the
     # SDK for use.
     class Configurator # rubocop:disable Metrics/ClassLength
+      # @api private
+      class NoopTextMapPropagator
+        EMPTY_LIST = [].freeze
+        private_constant(:EMPTY_LIST)
+
+        def inject(carrier, context: Context.current, setter: Context::Propagation.text_map_setter); end
+
+        def extract(carrier, context: Context.current, getter: Context::Propagation.text_map_getter)
+          context
+        end
+
+        def fields
+          EMPTY_LIST
+        end
+      end
+
       USE_MODE_UNSPECIFIED = 0
       USE_MODE_ONE = 1
       USE_MODE_ALL = 2
@@ -60,7 +76,7 @@ module OpenTelemetry
       # @param [String] service_name The value to be used as the service name
       def service_name=(service_name)
         self.resource = OpenTelemetry::SDK::Resources::Resource.create(
-          OpenTelemetry::SDK::Resources::Constants::SERVICE_RESOURCE[:name] => service_name
+          OpenTelemetry::SemanticConventions::Resource::SERVICE_NAME => service_name
         )
       end
 
@@ -70,7 +86,7 @@ module OpenTelemetry
       # @param [String] service_version The value to be used as the service version
       def service_version=(service_version)
         self.resource = OpenTelemetry::SDK::Resources::Resource.create(
-          OpenTelemetry::SDK::Resources::Constants::SERVICE_RESOURCE[:version] => service_version
+          OpenTelemetry::SemanticConventions::Resource::SERVICE_VERSION => service_version
         )
       end
 
@@ -149,21 +165,23 @@ module OpenTelemetry
       end
 
       def configure_span_processors
-        processors = @span_processors.empty? ? [wrapped_exporter_from_env].compact : @span_processors
+        processors = @span_processors.empty? ? wrapped_exporters_from_env.compact : @span_processors
         processors.each { |p| tracer_provider.add_span_processor(p) }
       end
 
-      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
-          OpenTelemetry.logger.warn "The #{exporter} exporter is unknown and cannot be configured, spans will not be exported"
-          nil
+      def wrapped_exporters_from_env
+        exporters = ENV.fetch('OTEL_TRACES_EXPORTER', 'otlp')
+        exporters.split(',').map do |exporter|
+          case exporter.strip
+          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
+            OpenTelemetry.logger.warn "The #{exporter} exporter is unknown and cannot be configured, spans will not be exported"
+            nil
+          end
         end
       end
 
@@ -179,7 +197,7 @@ module OpenTelemetry
           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
+            NoopTextMapPropagator.new
           end
         end
         OpenTelemetry.propagation = Context::Propagation::CompositeTextMapPropagator.compose_propagators((@propagators || propagators).compact)

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

@@ -31,14 +31,14 @@ module OpenTelemetry
           end
 
           def default
-            @default ||= create(Constants::SERVICE_RESOURCE[:name] => 'unknown_service').merge(process).merge(telemetry_sdk).merge(service_name_from_env)
+            @default ||= create(SemanticConventions::Resource::SERVICE_NAME => 'unknown_service').merge(process).merge(telemetry_sdk).merge(service_name_from_env)
           end
 
           def telemetry_sdk
             resource_attributes = {
-              Constants::TELEMETRY_SDK_RESOURCE[:name] => 'opentelemetry',
-              Constants::TELEMETRY_SDK_RESOURCE[:language] => 'ruby',
-              Constants::TELEMETRY_SDK_RESOURCE[:version] => OpenTelemetry::SDK::VERSION
+              SemanticConventions::Resource::TELEMETRY_SDK_NAME => 'opentelemetry',
+              SemanticConventions::Resource::TELEMETRY_SDK_LANGUAGE => 'ruby',
+              SemanticConventions::Resource::TELEMETRY_SDK_VERSION => OpenTelemetry::SDK::VERSION
             }
 
             resource_pairs = ENV['OTEL_RESOURCE_ATTRIBUTES']
@@ -55,11 +55,11 @@ module OpenTelemetry
 
           def process
             resource_attributes = {
-              Constants::PROCESS_RESOURCE[:pid] => Process.pid,
-              Constants::PROCESS_RESOURCE[:command] => $PROGRAM_NAME,
-              Constants::PROCESS_RUNTIME_RESOURCE[:name] => RUBY_ENGINE,
-              Constants::PROCESS_RUNTIME_RESOURCE[:version] => RUBY_VERSION,
-              Constants::PROCESS_RUNTIME_RESOURCE[:description] => RUBY_DESCRIPTION
+              SemanticConventions::Resource::PROCESS_PID => Process.pid,
+              SemanticConventions::Resource::PROCESS_COMMAND => $PROGRAM_NAME,
+              SemanticConventions::Resource::PROCESS_RUNTIME_NAME => RUBY_ENGINE,
+              SemanticConventions::Resource::PROCESS_RUNTIME_VERSION => RUBY_VERSION,
+              SemanticConventions::Resource::PROCESS_RUNTIME_DESCRIPTION => RUBY_DESCRIPTION
             }
 
             create(resource_attributes)
@@ -69,7 +69,7 @@ module OpenTelemetry
 
           def service_name_from_env
             service_name = ENV['OTEL_SERVICE_NAME']
-            create(Constants::SERVICE_RESOURCE[:name] => service_name) unless service_name.nil?
+            create(SemanticConventions::Resource::SERVICE_NAME => service_name) unless service_name.nil?
           end
         end
 

data/lib/opentelemetry/sdk/resources.rb

@@ -13,4 +13,3 @@ module OpenTelemetry
 end
 
 require 'opentelemetry/sdk/resources/resource'
-require 'opentelemetry/sdk/resources/constants'

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

@@ -146,9 +146,9 @@ module OpenTelemetry
 
             thread&.join(timeout)
             force_flush(timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
-            @exporter.shutdown(timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
             dropped_spans = lock { spans.size }
             report_dropped_spans(dropped_spans, reason: 'terminating') if dropped_spans.positive?
+            @exporter.shutdown(timeout: OpenTelemetry::Common::Utilities.maybe_timeout(timeout, start_time))
           end
 
           private
@@ -187,6 +187,10 @@ module OpenTelemetry
             result_code = @export_mutex.synchronize { @exporter.export(batch, timeout: timeout) }
             report_result(result_code, batch)
             result_code
+          rescue StandardError => e
+            report_result(FAILURE, batch)
+            @metrics_reporter.add_to_counter('otel.bsp.error', labels: { 'reason' => e.class.to_s })
+            FAILURE
           end
 
           def report_result(result_code, batch)
@@ -194,7 +198,7 @@ module OpenTelemetry
               @metrics_reporter.add_to_counter('otel.bsp.export.success')
               @metrics_reporter.add_to_counter('otel.bsp.exported_spans', increment: batch.size)
             else
-              OpenTelemetry.handle_error(message: "Unable to export #{batch.size} spans")
+              OpenTelemetry.handle_error(exception: ExportError.new("Unable to export #{batch.size} spans"))
               @metrics_reporter.add_to_counter('otel.bsp.export.failure')
               report_dropped_spans(batch.size, reason: 'export-failure')
             end

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

@@ -10,6 +10,8 @@ module OpenTelemetry
       # The Export module contains the built-in exporters and span processors for the OpenTelemetry
       # reference implementation.
       module Export
+        ExportError = Class.new(OpenTelemetry::Error)
+
         # Result codes for the SpanExporter#export method and the SpanProcessor#force_flush and SpanProcessor#shutdown methods.
 
         # The operation finished successfully.

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

@@ -131,7 +131,7 @@ module OpenTelemetry
         #
         # @return [self] returns itself
         def add_event(name, attributes: nil, timestamp: nil)
-          event = Event.new(name, truncate_attribute_values(attributes), wall_clock(timestamp))
+          event = Event.new(name, truncate_attribute_values(attributes), relative_timestamp(timestamp))
 
           @mutex.synchronize do
             if @ended
@@ -233,7 +233,7 @@ module OpenTelemetry
               OpenTelemetry.logger.warn('Calling finish on an ended Span.')
               return self
             end
-            @end_timestamp = wall_clock(end_timestamp)
+            @end_timestamp = relative_timestamp(end_timestamp)
             @attributes = validated_attributes(@attributes).freeze
             @events.freeze
             @ended = true
@@ -276,7 +276,7 @@ module OpenTelemetry
         end
 
         # @api private
-        def initialize(context, parent_context, name, kind, parent_span_id, span_limits, span_processors, attributes, links, start_timestamp, resource, instrumentation_library) # rubocop:disable Metrics/AbcSize
+        def initialize(context, parent_context, parent_span, name, kind, parent_span_id, span_limits, span_processors, attributes, links, start_timestamp, resource, instrumentation_library) # rubocop:disable Metrics/AbcSize,  Metrics/CyclomaticComplexity, Metrics/MethodLength,  Metrics/PerceivedComplexity
           super(span_context: context)
           @mutex = Mutex.new
           @name = name
@@ -291,17 +291,45 @@ module OpenTelemetry
           @total_recorded_events = 0
           @total_recorded_links = links&.size || 0
           @total_recorded_attributes = attributes&.size || 0
-          @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)
           @events = nil
-          @links = trim_links(links, span_limits.link_count_limit, span_limits.attribute_per_link_count_limit)
+          @links = trim_links(links, span_limits.link_count_limit, span_limits.link_attribute_count_limit)
+
+          # Times are hard. Whenever an explicit timestamp is provided
+          # (for Events or for the Span start_timestamp or end_timestamp),
+          # we use that as the recorded timestamp. An implicit Event timestamp
+          # and end_timestamp is computed as a monotonic clock offset from
+          # the realtime start_timestamp. The realtime start_timestamp is
+          # computed as a monotonic clock offset from the realtime
+          # start_timestamp of its parent span, if available, or it is
+          # fetched from the realtime system clock.
+          #
+          # We therefore have 3 start timestamps. The first two are used
+          # internally (and by child spans) to compute other timestamps.
+          # The last is the start timestamp actually recorded in the
+          # SpanData.
+          @monotonic_start_timestamp = monotonic_now
+          @realtime_start_timestamp = if parent_span.recording?
+                                        relative_realtime(parent_span.realtime_start_timestamp, parent_span.monotonic_start_timestamp)
+                                      else
+                                        realtime_now
+                                      end
+          @start_timestamp = if start_timestamp
+                               time_in_nanoseconds(start_timestamp)
+                             else
+                               @realtime_start_timestamp
+                             end
+          @end_timestamp = nil
           @span_processors.each { |processor| processor.on_start(self, parent_context) }
         end
 
         # TODO: Java implementation overrides finalize to log if a span isn't finished.
 
+        protected
+
+        attr_reader :monotonic_start_timestamp, :realtime_start_timestamp
+
         private
 
         def validated_attributes(attrs)
@@ -327,20 +355,23 @@ module OpenTelemetry
           attrs
         end
 
-        def trim_links(links, link_count_limit, attribute_per_link_count_limit) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def trim_links(links, link_count_limit, link_attribute_count_limit) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           # Fast path (likely) common cases.
           return nil if links.nil?
 
           if links.size <= link_count_limit &&
-             links.all? { |link| link.attributes.size <= attribute_per_link_count_limit && Internal.valid_attributes?(name, 'link', link.attributes) }
+             links.all? { |link| link.span_context.valid? && link.attributes.size <= link_attribute_count_limit && Internal.valid_attributes?(name, 'link', link.attributes) }
             return links.frozen? ? links : links.clone.freeze
           end
 
           # Slow path: trim attributes for each Link.
-          links.last(link_count_limit).map! do |link|
+          valid_links = links.select { |link| link.span_context.valid? }
+          excess_link_count = valid_links.size - link_count_limit
+          valid_links.pop(excess_link_count) if excess_link_count.positive?
+          valid_links.map! do |link|
             attrs = Hash[link.attributes] # link.attributes is frozen, so we need an unfrozen copy to adjust.
             attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
-            excess = attrs.size - attribute_per_link_count_limit
+            excess = attrs.size - link_attribute_count_limit
             excess.times { attrs.shift } if excess.positive?
             OpenTelemetry::Trace::Link.new(link.span_context, attrs)
           end.freeze
@@ -348,12 +379,12 @@ module OpenTelemetry
 
         def append_event(events, event) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           event_count_limit = @span_limits.event_count_limit
-          attribute_per_event_count_limit = @span_limits.attribute_per_event_count_limit
+          event_attribute_count_limit = @span_limits.event_attribute_count_limit
           valid_attributes = Internal.valid_attributes?(name, 'event', event.attributes)
 
           # Fast path (likely) common case.
           if events.size < event_count_limit &&
-             event.attributes.size <= attribute_per_event_count_limit &&
+             event.attributes.size <= event_attribute_count_limit &&
              valid_attributes
             return events << event
           end
@@ -362,20 +393,37 @@ module OpenTelemetry
           excess = events.size + 1 - event_count_limit
           events.shift(excess) if excess.positive?
 
-          excess = event.attributes.size - attribute_per_event_count_limit
+          excess = event.attributes.size - event_attribute_count_limit
           if excess.positive? || !valid_attributes
             attrs = Hash[event.attributes] # event.attributes is frozen, so we need an unfrozen copy to adjust.
             attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
-            excess = attrs.size - attribute_per_event_count_limit
+            excess = attrs.size - event_attribute_count_limit
             excess.times { attrs.shift } if excess.positive?
             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)
+        def relative_timestamp(timestamp)
+          return time_in_nanoseconds(timestamp) unless timestamp.nil?
+
+          relative_realtime(realtime_start_timestamp, monotonic_start_timestamp)
+        end
+
+        def time_in_nanoseconds(timestamp)
+          (timestamp.to_r * 1_000_000_000).to_i
+        end
+
+        def relative_realtime(realtime_base, monotonic_base)
+          realtime_base + (monotonic_now - monotonic_base)
+        end
+
+        def realtime_now
+          Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+        end
+
+        def monotonic_now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
         end
       end
       # rubocop:enable Metrics/ClassLength

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

@@ -22,10 +22,10 @@ module OpenTelemetry
         attr_reader :link_count_limit
 
         # The global default max number of attributes per {OpenTelemetry::SDK::Trace::Event}.
-        attr_reader :attribute_per_event_count_limit
+        attr_reader :event_attribute_count_limit
 
         # The global default max number of attributes per {OpenTelemetry::Trace::Link}.
-        attr_reader :attribute_per_link_count_limit
+        attr_reader :link_attribute_count_limit
 
         # Returns a {SpanLimits} with the desired values.
         #
@@ -35,21 +35,21 @@ module OpenTelemetry
                        attribute_length_limit: ENV['OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT'],
                        event_count_limit: Integer(ENV.fetch('OTEL_SPAN_EVENT_COUNT_LIMIT', 128)),
                        link_count_limit: Integer(ENV.fetch('OTEL_SPAN_LINK_COUNT_LIMIT', 128)),
-                       attribute_per_event_count_limit: attribute_count_limit,
-                       attribute_per_link_count_limit: attribute_count_limit)
+                       event_attribute_count_limit: Integer(ENV.fetch('OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT', 128)),
+                       link_attribute_count_limit: Integer(ENV.fetch('OTEL_LINK_ATTRIBUTE_COUNT_LIMIT', 128)))
           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
           raise ArgumentError, 'event_count_limit must be positive' unless event_count_limit.positive?
           raise ArgumentError, 'link_count_limit must be positive' unless link_count_limit.positive?
-          raise ArgumentError, 'attribute_per_event_count_limit must be positive' unless attribute_per_event_count_limit.positive?
-          raise ArgumentError, 'attribute_per_link_count_limit must be positive' unless attribute_per_link_count_limit.positive?
+          raise ArgumentError, 'event_attribute_count_limit must be positive' unless event_attribute_count_limit.positive?
+          raise ArgumentError, 'link_attribute_count_limit must be positive' unless link_attribute_count_limit.positive?
 
           @attribute_count_limit = attribute_count_limit
           @attribute_length_limit = attribute_length_limit.nil? ? nil : Integer(attribute_length_limit)
           @event_count_limit = event_count_limit
           @link_count_limit = link_count_limit
-          @attribute_per_event_count_limit = attribute_per_event_count_limit
-          @attribute_per_link_count_limit = attribute_per_link_count_limit
+          @event_attribute_count_limit = event_attribute_count_limit
+          @link_attribute_count_limit = link_attribute_count_limit
         end
 
         # The default {SpanLimits}.

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

@@ -31,12 +31,14 @@ module OpenTelemetry
           name ||= 'empty'
 
           with_parent ||= Context.current
+          parent_span = OpenTelemetry::Trace.current_span(with_parent)
           parent_span_context = OpenTelemetry::Trace.current_span(with_parent).context
           if parent_span_context.valid?
             parent_span_id = parent_span_context.span_id
             trace_id = parent_span_context.trace_id
           end
-          @tracer_provider.internal_create_span(name, kind, trace_id, parent_span_id, attributes, links, start_timestamp, with_parent, @instrumentation_library)
+
+          @tracer_provider.internal_create_span(name, kind, trace_id, parent_span_id, attributes, links, start_timestamp, with_parent, parent_span, @instrumentation_library)
         end
       end
     end

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

@@ -33,6 +33,7 @@ module OpenTelemetry
                        span_limits: SpanLimits::DEFAULT)
           @mutex = Mutex.new
           @registry = {}
+          @registry_mutex = Mutex.new
           @span_processors = []
           @span_limits = span_limits
           @sampler = sampler
@@ -51,7 +52,7 @@ module OpenTelemetry
           name ||= ''
           version ||= ''
           OpenTelemetry.logger.warn 'calling TracerProvider#tracer without providing a tracer name.' if name.empty?
-          @mutex.synchronize { @registry[Key.new(name, version)] ||= Tracer.new(name, version, self) }
+          @registry_mutex.synchronize { @registry[Key.new(name, version)] ||= Tracer.new(name, version, self) }
         end
 
         # Attempts to stop all the activity for this {TracerProvider}. Calls
@@ -125,8 +126,15 @@ module OpenTelemetry
         end
 
         # @api private
-        def internal_create_span(name, kind, trace_id, parent_span_id, attributes, links, start_timestamp, parent_context, instrumentation_library) # rubocop:disable Metrics/MethodLength
+        def internal_create_span(name, kind, trace_id, parent_span_id, attributes, links, start_timestamp, parent_context, parent_span, instrumentation_library) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          parent_span_context = parent_span.context
+          if parent_span_context.valid?
+            parent_span_id = parent_span_context.span_id
+            trace_id = parent_span_context.trace_id
+          end
+          name ||= 'empty'
           trace_id ||= @id_generator.generate_trace_id
+          kind ||= :internal
           result = @sampler.should_sample?(trace_id: trace_id, parent_context: parent_context, links: links, name: name, kind: kind, attributes: attributes)
           span_id = @id_generator.generate_span_id
           if result.recording? && !@stopped
@@ -136,6 +144,7 @@ module OpenTelemetry
             Span.new(
               context,
               parent_context,
+              parent_span,
               name,
               kind,
               parent_span_id,

data/lib/opentelemetry/sdk/version.rb

@@ -7,6 +7,6 @@
 module OpenTelemetry
   module SDK
     ## Current OpenTelemetry version
-    VERSION = '1.0.0.rc2'
+    VERSION = '1.0.2'
   end
 end

data/lib/opentelemetry/sdk.rb

@@ -7,6 +7,7 @@
 require 'opentelemetry'
 require 'opentelemetry/common'
 require 'opentelemetry-instrumentation-base'
+require 'opentelemetry-semantic_conventions'
 
 # OpenTelemetry is an open source observability framework, providing a
 # general-purpose API, SDK, and related tools required for the instrumentation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-sdk
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc2
+  version: 1.0.2
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-24 00:00:00.000000000 Z
+date: 2021-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -16,42 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.rc2
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.rc2
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-common
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.19.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.0
+        version: 0.19.3
 - !ruby/object:Gem::Dependency
   name: opentelemetry-instrumentation-base
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.1
+        version: 0.19.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.1
+        version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-semantic_conventions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -95,19 +109,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: opentelemetry-exporter-jaeger
+  name: opentelemetry-exporter-zipkin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.19.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.18.0
+        version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -178,6 +206,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.6
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A stats collection and distributed tracing framework
 email:
 - cncf-opentelemetry-contributors@lists.cncf.io
@@ -196,7 +238,6 @@ files:
 - lib/opentelemetry/sdk/instrumentation_library.rb
 - lib/opentelemetry/sdk/internal.rb
 - lib/opentelemetry/sdk/resources.rb
-- lib/opentelemetry/sdk/resources/constants.rb
 - lib/opentelemetry/sdk/resources/resource.rb
 - lib/opentelemetry/sdk/trace.rb
 - lib/opentelemetry/sdk/trace/event.rb
@@ -224,10 +265,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/v1.0.0.rc2/file.CHANGELOG.html
+  changelog_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v1.0.2/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/v1.0.0.rc2
+  documentation_uri: https://open-telemetry.github.io/opentelemetry-ruby/opentelemetry-sdk/v1.0.2
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -239,9 +280,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.1.6
 signing_key: 

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

@@ -1,205 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Resources
-      module Constants
-        # Attributes describing a service instance.
-        SERVICE_RESOURCE = {
-          # Logical name of the service.
-          name: 'service.name',
-
-          # A namespace for `service.name`.
-          namespace: 'service.namespace',
-
-          # The string ID of the service instance.
-          instance_id: 'service.instance.id',
-
-          # The version string of the service API or implementation.
-          version: 'service.version'
-        }.freeze
-
-        # Attributes describing the telemetry library.
-        TELEMETRY_SDK_RESOURCE = {
-          # The name of the telemetry library.
-          name: 'telemetry.sdk.name',
-
-          # The language of the telemetry library and of the code instrumented with it.
-          language: 'telemetry.sdk.language',
-
-          # The version string of the telemetry library
-          version: 'telemetry.sdk.version'
-        }.freeze
-
-        # Attributes defining a compute unit (e.g. Container, Process, Lambda
-        # Function).
-        CONTAINER_RESOURCE = {
-          # The container name.
-          name: 'container.name',
-
-          # The name of the image the container was built on.
-          image_name: 'container.image.name',
-
-          # The container image tag.
-          image_tag: 'container.image.tag'
-        }.freeze
-
-        FAAS_RESOURCE = {
-          # The name of the function being executed.
-          name: 'faas.name',
-
-          # The unique name of the function being executed.
-          id: 'faas.id',
-
-          # The version string of the function being executed.
-          version: 'faas.version',
-
-          # The execution environment ID as a string.
-          instance: 'faas.instance'
-        }.freeze
-
-        # Attributes defining a deployment service (e.g. Kubernetes).
-        K8S_RESOURCE = {
-          # 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',
-
-          # 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.
-        PROCESS_RESOURCE = {
-          # Process identifier (PID).
-          pid: 'process.pid',
-
-          # The name of the process executable.
-          executable_name: 'process.executable.name',
-
-          # The full path to the process executable.
-          executable_path: 'process.executable.path',
-
-          # The command used to launch the process (i.e. the command name).
-          command: 'process.command',
-
-          # The full command used to launch the process as a single string
-          # representing the full command.
-          command_line: 'process.command_line',
-
-          # All the command arguments (including the command/executable itself)
-          # as received by the process.
-          command_args: 'process.command_args',
-
-          # The username of the user that owns the process.
-          owner: 'process.owner'
-        }.freeze
-
-        # Attributes defining the single (language) runtime instance which is monitored.
-        PROCESS_RUNTIME_RESOURCE = {
-          # The name of the runtime of this process.
-          name: 'process.runtime.name',
-
-          # The version of the runtime of this process, as returned by the runtime
-          # without modification.
-          version: 'process.runtime.version',
-
-          # An additional description about the runtime of the process, for example
-          # a specific vendor customization of the runtime environment.
-          description: 'process.runtime.description'
-        }.freeze
-
-        # Attributes defining a computing instance (e.g. host).
-        HOST_RESOURCE = {
-          # Unique host id. For Cloud this must be the instance_id assigned by the
-          # cloud provider
-          id: 'host.id',
-
-          # Name of the host. It may contain what hostname returns on Unix systems,
-          # the fully qualified, or a name specified by the user.
-          name: 'host.name',
-
-          # Type of host. For Cloud this must be the machine type.
-          type: 'host.type',
-
-          # Name of the VM image or OS install the host was instantiated from.
-          image_name: 'host.image.name',
-
-          # VM image id. For Cloud, this value is from the provider.
-          image_id: 'host.image.id',
-
-          # The version string of the VM image.
-          image_version: 'host.image.version'
-        }.freeze
-
-        # Attributes defining a running environment (e.g. Cloud, Data Center).
-        CLOUD_RESOURCE = {
-          # Name of the cloud provider. Example values are aws, azure, gcp.
-          provider: 'cloud.provider',
-
-          # The cloud account id used to identify different entities.
-          account_id: 'cloud.account.id',
-
-          # A specific geographical location where different entities can run.
-          region: 'cloud.region',
-
-          # Availability zones are a sub set of the region connected through low-latency links.
-          availability_zone: 'cloud.availability_zone'
-        }.freeze
-      end
-    end
-  end
-end