opentelemetry-sdk 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f952e49fadd62c0a174e8edfebff16e774a8421fd361c05a24af58402d2b267
-  data.tar.gz: e34fd801558f119a59e6399f1f66ac9408413af12bf72a8ab9788a1d2a303e61
+  metadata.gz: 3a01fcf121db23108ffb47d196f9594993018bb1b945242710620bb87daa8320
+  data.tar.gz: ef3b3e9cd4e2853a22ffb149e7a18cbd021988412d24c40350192e222b3be58b
 SHA512:
-  metadata.gz: 7d67df753f0f6af7626833ab968994bcbf3c6fd387638fbd0290c46ead629e25a5ccb2c421cb86a9c129876f007c9f1ce0bbac148e5830223352768624079399
-  data.tar.gz: '07867ecc29a180417a4e2cc3243fd9cec2857390799192bc8e6b5be5641c4d64225ca5dcadf9311c23b73a4ab09729cca3006c3ee92aa39924d5887edf30ca3b'
+  metadata.gz: 5da08d0e902ece66efc7afa892f99f2b9fe3bcd5b89b51cd3da1a565a23ab0917eb1c39d6fb44ed6b82a71048624cb357539d9b6305b1a0c8debc594ef2467d3
+  data.tar.gz: 5fe47387c0d91e8d5436be4d4464839f08a9ae46964e8fe1679ab6ef7e7bf8b7a59ae086472d465e6f12c57b70c712a982064351f287a8ebbb6bbe173c37b45d

data/CHANGELOG.md

@@ -1 +1,24 @@
 # Release History: opentelemetry-sdk
+
+### v0.6.0 / 2020-09-10
+
+* BREAKING CHANGE: Rename Resource labels to attributes 
+* BREAKING CHANGE: Export resource from Span/SpanData instead of library_resource
+* BREAKING CHANGE: Rename CorrelationContext to Baggage
+* BREAKING CHANGE: Rename Text* to TextMap* (propagators, injectors, extractors)
+* BREAKING CHANGE: Rename span.record_error to span.record_exception
+* BREAKING CHANGE: Update samplers to match spec
+* BREAKING CHANGE: Remove support for lazy event creation
+
+* ADDED: Add OTLP exporter
+* ADDED: Add support for OTEL_LOG_LEVEL env var
+* FIXED: Rename Resource labels to attributes 
+* ADDED: Environment variable resource detection
+* ADDED: BatchSpanProcessor environment variable support
+* FIXED: Remove semver prefix
+* FIXED: Docs for array valued attributes
+* ADDED: Add hex_trace_id and hex_span_id helpers to SpanData
+* FIXED: Fix ProbabilitySampler
+* ADDED: Implement GetCorrelations
+* FIXED: Change default Sampler to ParentOrElse(AlwaysOn)
+* FIXED: Fix probability sampler

data/README.md

@@ -41,7 +41,7 @@ tracer.in_span('foo') do |span|
   # set an attribute
   span.set_attribute('platform', 'osx')
   # add an event
-  span.add_event(name: 'event in bar')
+  span.add_event('event in bar')
   # create bar as child of foo
   tracer.in_span('bar') do |child_span|
     # inspect the span

data/lib/opentelemetry/sdk.rb

@@ -61,7 +61,7 @@ module OpenTelemetry
 end
 
 require 'opentelemetry/sdk/configurator'
-require 'opentelemetry/sdk/correlation_context'
+require 'opentelemetry/sdk/baggage'
 require 'opentelemetry/sdk/internal'
 require 'opentelemetry/sdk/instrumentation_library'
 require 'opentelemetry/sdk/resources'

data/lib/opentelemetry/sdk/baggage.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Copyright 2019 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/{correlation_context → baggage}/builder.rb

@@ -6,8 +6,8 @@
 
 module OpenTelemetry
   module SDK
-    module CorrelationContext
-      # SDK implementation of CorrelationContext::Builder
+    module Baggage
+      # SDK implementation of Baggage::Builder
       class Builder
         attr_reader :entries
 
@@ -15,7 +15,7 @@ module OpenTelemetry
           @entries = entries
         end
 
-        # Set key-value in the to-be-created correlation context
+        # 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
@@ -23,14 +23,14 @@ module OpenTelemetry
           @entries[key] = value.to_s
         end
 
-        # Removes key from the to-be-created correlation context
+        # 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 correlations from the to-be-created correlation context
+        # Clears all baggage from the to-be-created baggage
         def clear
           @entries.clear
         end

data/lib/opentelemetry/sdk/{correlation_context → baggage}/manager.rb

@@ -6,38 +6,38 @@
 
 module OpenTelemetry
   module SDK
-    module CorrelationContext
-      # Manages correlation context
+    module Baggage
+      # Manages baggage
       class Manager
-        CORRELATION_CONTEXT_KEY = OpenTelemetry::CorrelationContext::Propagation::ContextKeys.correlation_context_key
-        EMPTY_CORRELATION_CONTEXT = {}.freeze
-        private_constant(:CORRELATION_CONTEXT_KEY, :EMPTY_CORRELATION_CONTEXT)
+        BAGGAGE_KEY = OpenTelemetry::Baggage::Propagation::ContextKeys.baggage_key
+        EMPTY_BAGGAGE = {}.freeze
+        private_constant(:BAGGAGE_KEY, :EMPTY_BAGGAGE)
 
-        # Used to chain modifications to correlation context. The result is a
-        # context with an updated correlation context. If only a single
-        # modification is being made to correlation context, use the other
+        # 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 correlation context. Defaults to +Context.current+
+        #   modified baggage. Defaults to +Context.current+
         # @return [Context]
         def build_context(context: Context.current)
-          builder = Builder.new(correlations_for(context).dup)
+          builder = Builder.new(baggage_for(context).dup)
           yield builder
-          context.set_value(CORRELATION_CONTEXT_KEY, builder.entries)
+          context.set_value(BAGGAGE_KEY, builder.entries)
         end
 
-        # Returns a new context with empty correlations
+        # Returns a new context with empty baggage
         #
-        # @param [optional Context] context Context to clear correlations from. Defaults
+        # @param [optional Context] context Context to clear baggage from. Defaults
         #   to +Context.current+
         # @return [Context]
         def clear(context: Context.current)
-          context.set_value(CORRELATION_CONTEXT_KEY, EMPTY_CORRELATION_CONTEXT)
+          context.set_value(BAGGAGE_KEY, EMPTY_BAGGAGE)
         end
 
-        # Returns the corresponding correlation value (or nil) for key
+        # 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
@@ -45,7 +45,17 @@ module OpenTelemetry
         #   Defaults to +Context.current+
         # @return [String]
         def value(key, context: Context.current)
-          correlations_for(context)[key]
+          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
@@ -56,30 +66,30 @@ module OpenTelemetry
         #   value. Defaults to +Context.current+
         # @return [Context]
         def set_value(key, value, context: Context.current)
-          new_correlations = correlations_for(context).dup
-          new_correlations[key] = value
-          context.set_value(CORRELATION_CONTEXT_KEY, new_correlations)
+          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 correlation
+        # @param [optional Context] context The context to remove baggage
         #   from. Defaults to +Context.current+
         # @return [Context]
         def remove_value(key, context: Context.current)
-          correlations = correlations_for(context)
-          return context unless correlations.key?(key)
+          baggage = baggage_for(context)
+          return context unless baggage.key?(key)
 
-          new_correlations = correlations.dup
-          new_correlations.delete(key)
-          context.set_value(CORRELATION_CONTEXT_KEY, new_correlations)
+          new_baggage = baggage.dup
+          new_baggage.delete(key)
+          context.set_value(BAGGAGE_KEY, new_baggage)
         end
 
         private
 
-        def correlations_for(context)
-          context.value(CORRELATION_CONTEXT_KEY) || EMPTY_CORRELATION_CONTEXT
+        def baggage_for(context)
+          context.value(BAGGAGE_KEY) || EMPTY_BAGGAGE
         end
       end
     end

data/lib/opentelemetry/sdk/configurator.rb

@@ -15,32 +15,33 @@ module OpenTelemetry
 
       private_constant :USE_MODE_UNSPECIFIED, :USE_MODE_ONE, :USE_MODE_ALL
 
-      attr_writer :logger, :http_extractors, :http_injectors, :text_extractors,
-                  :text_injectors
+      attr_writer :logger, :http_extractors, :http_injectors, :text_map_extractors,
+                  :text_map_injectors
 
       def initialize
         @instrumentation_names = []
         @instrumentation_config_map = {}
         @http_extractors = nil
         @http_injectors = nil
-        @text_extractors = nil
-        @text_injectors = nil
+        @text_map_extractors = nil
+        @text_map_injectors = nil
         @span_processors = []
         @use_mode = USE_MODE_UNSPECIFIED
         @resource = Resources::Resource.telemetry_sdk
       end
 
       def logger
-        @logger ||= Logger.new(STDOUT)
+        @logger ||= OpenTelemetry.logger
       end
 
       # Accepts a resource object that is merged with the default telemetry sdk
       # resource. The use of this method is optional, and is provided as means
-      # to add additional resource information.
+      # to include additional resource information.
+      # If a resource key collision occurs the passed in resource takes priority.
       #
       # @param [Resource] new_resource The resource to be merged
       def resource=(new_resource)
-        @resource = @resource.merge(new_resource)
+        @resource = new_resource.merge(@resource)
       end
 
       # Install an instrumentation with specificied optional +config+.
@@ -89,7 +90,7 @@ module OpenTelemetry
       #   - install instrumentation
       def configure
         OpenTelemetry.logger = logger
-        OpenTelemetry.correlations = CorrelationContext::Manager.new
+        OpenTelemetry.baggage = Baggage::Manager.new
         configure_propagation
         configure_span_processors
         OpenTelemetry.tracer_provider = tracer_provider
@@ -130,8 +131,8 @@ module OpenTelemetry
       def configure_propagation
         OpenTelemetry.propagation.http = create_propagator(@http_injectors || default_http_injectors,
                                                            @http_extractors || default_http_extractors)
-        OpenTelemetry.propagation.text = create_propagator(@text_injectors || default_text_injectors,
-                                                           @text_extractors || default_text_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)
@@ -143,27 +144,27 @@ module OpenTelemetry
       end
 
       def default_http_injectors
-        default_text_injectors
+        default_text_map_injectors
       end
 
       def default_http_extractors
         [
           OpenTelemetry::Trace::Propagation::TraceContext.rack_extractor,
-          OpenTelemetry::CorrelationContext::Propagation.rack_extractor
+          OpenTelemetry::Baggage::Propagation.rack_extractor
         ]
       end
 
-      def default_text_injectors
+      def default_text_map_injectors
         [
-          OpenTelemetry::Trace::Propagation::TraceContext.text_injector,
-          OpenTelemetry::CorrelationContext::Propagation.text_injector
+          OpenTelemetry::Trace::Propagation::TraceContext.text_map_injector,
+          OpenTelemetry::Baggage::Propagation.text_map_injector
         ]
       end
 
-      def default_text_extractors
+      def default_text_map_extractors
         [
-          OpenTelemetry::Trace::Propagation::TraceContext.text_extractor,
-          OpenTelemetry::CorrelationContext::Propagation.text_extractor
+          OpenTelemetry::Trace::Propagation::TraceContext.text_map_extractor,
+          OpenTelemetry::Baggage::Propagation.text_map_extractor
         ]
       end
     end

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

@@ -13,29 +13,40 @@ module OpenTelemetry
         class << self
           private :new # rubocop:disable Style/AccessModifierDeclarations
 
-          # Returns a newly created {Resource} with the specified labels
+          # Returns a newly created {Resource} with the specified attributes
           #
-          # @param [Hash{String => String, Numeric, Boolean} labels Hash of key-value pairs to be used
-          #   as labels for this resource
-          # @raise [ArgumentError] If label keys and values are not strings
+          # @param [Hash{String => String, Numeric, Boolean} attributes Hash of key-value pairs to be used
+          #   as attributes for this resource
+          # @raise [ArgumentError] If attribute keys and values are not strings
           # @return [Resource]
-          def create(labels = {})
-            frozen_labels = labels.each_with_object({}) do |(k, v), memo|
-              raise ArgumentError, 'label keys must be strings' unless k.is_a?(String)
-              raise ArgumentError, 'label values must be strings, integers, floats, or booleans' unless Internal.valid_value?(v)
+          def create(attributes = {})
+            frozen_attributes = attributes.each_with_object({}) do |(k, v), memo|
+              raise ArgumentError, 'attribute keys must be strings' unless k.is_a?(String)
+              raise ArgumentError, 'attribute values must be strings, integers, floats, or booleans' unless Internal.valid_value?(v)
 
               memo[-k] = v.freeze
             end.freeze
 
-            new(frozen_labels)
+            new(frozen_attributes)
           end
 
           def telemetry_sdk
-            create(
+            resource_attributes = {
               Constants::TELEMETRY_SDK_RESOURCE[:name] => 'opentelemetry',
               Constants::TELEMETRY_SDK_RESOURCE[:language] => 'ruby',
-              Constants::TELEMETRY_SDK_RESOURCE[:version] => "semver:#{OpenTelemetry::SDK::VERSION}"
-            )
+              Constants::TELEMETRY_SDK_RESOURCE[:version] => OpenTelemetry::SDK::VERSION
+            }
+
+            resource_pairs = ENV['OTEL_RESOURCE_ATTRIBUTES']
+            return create(resource_attributes) unless resource_pairs.is_a?(String)
+
+            resource_pairs.split(',').each do |pair|
+              key, value = pair.split('=')
+              resource_attributes[key] = value
+            end
+
+            resource_attributes.delete_if { |_key, value| value.nil? || value.empty? }
+            create(resource_attributes)
           end
         end
 
@@ -44,18 +55,18 @@ module OpenTelemetry
         # Users should use the {create} factory method to obtain a {Resource}
         # instance.
         #
-        # @param [Hash<String, String>] frozen_labels Frozen-hash of frozen-string
-        #  key-value pairs to be used as labels for this resource
+        # @param [Hash<String, String>] frozen_attributes Frozen-hash of frozen-string
+        #  key-value pairs to be used as attributes for this resource
         # @return [Resource]
-        def initialize(frozen_labels)
-          @labels = frozen_labels
+        def initialize(frozen_attributes)
+          @attributes = frozen_attributes
         end
 
-        # Returns an enumerator for labels of this {Resource}
+        # Returns an enumerator for attributes of this {Resource}
         #
         # @return [Enumerator]
-        def label_enumerator
-          @label_enumerator ||= labels.to_enum
+        def attribute_enumerator
+          @attribute_enumerator ||= attributes.to_enum
         end
 
         # Returns a new, merged {Resource} by merging the current {Resource} with
@@ -68,16 +79,16 @@ module OpenTelemetry
         def merge(other)
           return self unless other.is_a?(Resource)
 
-          merged_labels = labels.merge(other.labels) do |_, old_v, new_v|
+          merged_attributes = attributes.merge(other.attributes) do |_, old_v, new_v|
             old_v.empty? ? new_v : old_v
           end
 
-          self.class.send(:new, merged_labels.freeze)
+          self.class.send(:new, merged_attributes.freeze)
         end
 
         protected
 
-        attr_reader :labels
+        attr_reader :attributes
       end
     end
   end

data/lib/opentelemetry/sdk/trace.rb

@@ -15,6 +15,7 @@ end
 
 require 'opentelemetry/sdk/trace/samplers'
 require 'opentelemetry/sdk/trace/config'
+require 'opentelemetry/sdk/trace/event'
 require 'opentelemetry/sdk/trace/export'
 require 'opentelemetry/sdk/trace/multi_span_processor'
 require 'opentelemetry/sdk/trace/noop_span_processor'

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

@@ -10,7 +10,7 @@ module OpenTelemetry
       module Config
         # Class that holds global trace parameters.
         class TraceConfig
-          DEFAULT_SAMPLER = Samplers::ALWAYS_ON
+          DEFAULT_SAMPLER = Samplers.parent_based(root: Samplers::ALWAYS_ON)
           DEFAULT_MAX_ATTRIBUTES_COUNT = 32
           DEFAULT_MAX_EVENTS_COUNT = 128
           DEFAULT_MAX_LINKS_COUNT = 32
@@ -30,13 +30,13 @@ module OpenTelemetry
           # 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}.
+          # The global default max number of {OpenTelemetry::SDK::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}.
+          # The global default max number of attributes per {OpenTelemetry::SDK::Trace::Event}.
           attr_reader :max_attributes_per_event
 
           # The global default max number of attributes per {OpenTelemetry::Trace::Link}.

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      # A text annotation with a set of attributes and a timestamp.
+      class Event
+        EMPTY_ATTRIBUTES = {}.freeze
+
+        private_constant :EMPTY_ATTRIBUTES
+
+        # Returns the name of this event
+        #
+        # @return [String]
+        attr_reader :name
+
+        # Returns the frozen attributes for this event
+        #
+        # @return [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
+        attr_reader :attributes
+
+        # Returns the timestamp for this event
+        #
+        # @return [Time]
+        attr_reader :timestamp
+
+        # Returns a new immutable {Event}.
+        #
+        # @param [String] name The name of this event
+        # @param [optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
+        #   attributes A hash of attributes for this event. Attributes will be
+        #   frozen during Event initialization.
+        # @param [optional Time] timestamp The timestamp for this event.
+        #   Defaults to Time.now.
+        # @return [Event]
+        def initialize(name:, attributes: nil, timestamp: nil)
+          @name = name
+          @attributes = attributes.freeze || EMPTY_ATTRIBUTES
+          @timestamp = timestamp || Time.now
+        end
+      end
+    end
+  end
+end

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

@@ -23,17 +23,28 @@ module OpenTelemetry
         # 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)
-
+          # Returns a new instance of the {BatchSpanProcessor}.
+          #
+          # @param [SpanExporter] exporter
+          # @param [Numeric] exporter_timeout_millis the delay interval between two
+          #   consecutive exports. Defaults to the value of the OTEL_BSP_EXPORT_TIMEOUT_MILLIS
+          #   environment variable, if set, or 30,000 (30 seconds).
+          # @param [Numeric] schedule_delay_millis the maximum allowed time to export data.
+          #   Defaults to the value of the OTEL_BSP_SCHEDULE_DELAY_MILLIS environment
+          #   variable, if set, or 5,000 (5 seconds).
+          # @param [Integer] max_queue_size the maximum queue size in spans.
+          #   Defaults to the value of the OTEL_BSP_MAX_QUEUE_SIZE environment
+          #   variable, if set, or 2048.
+          # @param [Integer] max_export_batch_size the maximum batch size in spans.
+          #   Defaults to the value of the OTEL_BSP_MAX_EXPORT_BATCH_SIZE environment
+          #   variable, if set, or 512.
+          #
+          # @return a new instance of the {BatchSpanProcessor}.
           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)
+                         exporter_timeout_millis: Float(ENV.fetch('OTEL_BSP_EXPORT_TIMEOUT_MILLIS', 30_000)),
+                         schedule_delay_millis: Float(ENV.fetch('OTEL_BSP_SCHEDULE_DELAY_MILLIS', 5_000)),
+                         max_queue_size: Integer(ENV.fetch('OTEL_BSP_MAX_QUEUE_SIZE', 2048)),
+                         max_export_batch_size: Integer(ENV.fetch('OTEL_BSP_MAX_EXPORT_BATCH_SIZE', 512)))
             raise ArgumentError if max_export_batch_size > max_queue_size
 
             @exporter = exporter

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

@@ -7,15 +7,15 @@
 require 'opentelemetry/sdk/trace/samplers/decision'
 require 'opentelemetry/sdk/trace/samplers/result'
 require 'opentelemetry/sdk/trace/samplers/constant_sampler'
-require 'opentelemetry/sdk/trace/samplers/parent_or_else'
-require 'opentelemetry/sdk/trace/samplers/probability_sampler'
+require 'opentelemetry/sdk/trace/samplers/parent_based'
+require 'opentelemetry/sdk/trace/samplers/trace_id_ratio_based'
 
 module OpenTelemetry
   module SDK
     module Trace
       # The Samplers module contains the sampling logic for OpenTelemetry. The
-      # reference implementation provides a {ProbabilitySampler}, {ALWAYS_ON},
-      # {ALWAYS_OFF}, and {ParentOrElse}.
+      # reference implementation provides a {TraceIdRatioBased}, {ALWAYS_ON},
+      # {ALWAYS_OFF}, and {ParentBased}.
       #
       # Custom samplers can be provided by SDK users. The required interface is:
       #
@@ -41,9 +41,8 @@ module OpenTelemetry
         NOT_RECORD = Result.new(decision: Decision::NOT_RECORD)
         RECORD = Result.new(decision: Decision::RECORD)
         SAMPLING_HINTS = [Decision::NOT_RECORD, Decision::RECORD, Decision::RECORD_AND_SAMPLED].freeze
-        APPLY_PROBABILITY_TO_SYMBOLS = %i[root_spans root_spans_and_remote_parent all_spans].freeze
 
-        private_constant(:RECORD_AND_SAMPLED, :NOT_RECORD, :RECORD, :SAMPLING_HINTS, :APPLY_PROBABILITY_TO_SYMBOLS)
+        private_constant(:RECORD_AND_SAMPLED, :NOT_RECORD, :RECORD, :SAMPLING_HINTS)
 
         # Returns a {Result} with {Decision::RECORD_AND_SAMPLED}.
         ALWAYS_ON = ConstantSampler.new(result: RECORD_AND_SAMPLED, description: 'AlwaysOnSampler')
@@ -51,38 +50,46 @@ module OpenTelemetry
         # Returns a {Result} with {Decision::NOT_RECORD}.
         ALWAYS_OFF = ConstantSampler.new(result: NOT_RECORD, description: 'AlwaysOffSampler')
 
-        # Returns a new sampler. It either respects the parent span's sampling
-        # decision or delegates to delegate_sampler for root spans.
+        # Returns a new sampler. It delegates to samplers according to the following rules:
         #
-        # @param [Sampler] delegate_sampler The sampler to which the sampling
-        #   decision is delegated for root spans.
-        def self.parent_or_else(delegate_sampler)
-          ParentOrElse.new(delegate_sampler)
+        # | Parent | parent.remote? | parent.trace_flags.sampled? | Invoke sampler |
+        # |--|--|--|--|
+        # | absent | n/a | n/a | root |
+        # | present | true | true | remote_parent_sampled |
+        # | present | true | false | remote_parent_not_sampled |
+        # | present | false | true | local_parent_sampled |
+        # | present | false | false | local_parent_not_sampled |
+        #
+        # @param [Sampler] root The sampler to which the sampling
+        #   decision is delegated for spans with no parent (root spans).
+        # @param [optional Sampler] remote_parent_sampled The sampler to which the sampling
+        #   decision is delegated for remote parent sampled spans. Defaults to ALWAYS_ON.
+        # @param [optional Sampler] remote_parent_not_sampled The sampler to which the sampling
+        #   decision is delegated for remote parent not sampled spans. Defaults to ALWAYS_OFF.
+        # @param [optional Sampler] local_parent_sampled The sampler to which the sampling
+        #   decision is delegated for local parent sampled spans. Defaults to ALWAYS_ON.
+        # @param [optional Sampler] local_parent_not_sampled The sampler to which the sampling
+        #   decision is delegated for local parent not sampld spans. Defaults to ALWAYS_OFF.
+        def self.parent_based(
+          root:,
+          remote_parent_sampled: ALWAYS_ON,
+          remote_parent_not_sampled: ALWAYS_OFF,
+          local_parent_sampled: ALWAYS_ON,
+          local_parent_not_sampled: ALWAYS_OFF
+        )
+          ParentBased.new(root, remote_parent_sampled, remote_parent_not_sampled, local_parent_sampled, local_parent_not_sampled)
         end
 
-        # Returns a new sampler. The probability of sampling a trace is equal
-        # to that of the specified probability.
+        # Returns a new sampler. The ratio describes the proportion of the trace ID
+        # space that is sampled.
         #
-        # @param [Numeric] probability The desired probability of sampling.
+        # @param [Numeric] ratio The desired sampling ratio.
         #   Must be within [0.0, 1.0].
-        # @param [optional Boolean] ignore_parent Whether to ignore parent
-        #   sampling. Defaults to not ignore parent sampling.
-        # @param [optional Symbol] apply_probability_to Whether to apply
-        #   probability sampling to root spans, root spans and remote parents,
-        #   or all spans. Allowed values include :root_spans, :root_spans_and_remote_parent,
-        #   and :all_spans. Defaults to :root_spans_and_remote_parent.
-        # @raise [ArgumentError] if probability is out of range
-        # @raise [ArgumentError] if apply_probability_to is not one of the allowed symbols
-        def self.probability(probability,
-                             ignore_parent: false,
-                             apply_probability_to: :root_spans_and_remote_parent)
-          raise ArgumentError, 'probability must be in range [0.0, 1.0]' unless (0.0..1.0).include?(probability)
-          raise ArgumentError, 'apply_probability_to' unless APPLY_PROBABILITY_TO_SYMBOLS.include?(apply_probability_to)
+        # @raise [ArgumentError] if ratio is out of range
+        def self.trace_id_ratio_based(ratio)
+          raise ArgumentError, 'ratio must be in range [0.0, 1.0]' unless (0.0..1.0).include?(ratio)
 
-          ProbabilitySampler.new(probability,
-                                 ignore_parent: ignore_parent,
-                                 apply_to_remote_parent: apply_probability_to != :root_spans,
-                                 apply_to_all_spans: apply_probability_to == :all_spans)
+          TraceIdRatioBased.new(ratio)
         end
       end
     end

data/lib/opentelemetry/sdk/trace/samplers/parent_based.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Samplers
+        # @api private
+        #
+        # This is a composite sampler. ParentBased helps distinguished between the
+        # following cases:
+        #   * No parent (root span).
+        #   * Remote parent (SpanContext.remote? with trace_flags.sampled?)
+        #   * Remote parent (SpanContext.remote? with !trace_flags.sampled?)
+        #   * Local parent (!SpanContext.remote? with trace_flags.sampled?)
+        #   * Local parent (!SpanContext.remote? with !trace_flags.sampled?)
+        class ParentBased
+          def initialize(root, remote_parent_sampled, remote_parent_not_sampled, local_parent_sampled, local_parent_not_sampled)
+            @root = root
+            @remote_parent_sampled = remote_parent_sampled
+            @remote_parent_not_sampled = remote_parent_not_sampled
+            @local_parent_sampled = local_parent_sampled
+            @local_parent_not_sampled = local_parent_not_sampled
+          end
+
+          # @api private
+          #
+          # See {Samplers}.
+          def description
+            "ParentBased{root=#{@root.description}, remote_parent_sampled=#{@remote_parent_sampled.description}, remote_parent_not_sampled=#{@remote_parent_not_sampled.description}, local_parent_sampled=#{@local_parent_sampled.description}, local_parent_not_sampled=#{@local_parent_not_sampled.description}}"
+          end
+
+          # @api private
+          #
+          # See {Samplers}.
+          def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+            delegate = if parent_context.nil?
+                         @root
+                       elsif parent_context.remote?
+                         parent_context.trace_flags.sampled? ? @remote_parent_sampled : @remote_parent_not_sampled
+                       else
+                         parent_context.trace_flags.sampled? ? @local_parent_sampled : @local_parent_not_sampled
+                       end
+            delegate.should_sample?(trace_id: trace_id, parent_context: parent_context, links: links, name: name, kind: kind, attributes: attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/sdk/trace/samplers/trace_id_ratio_based.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Samplers
+        # @api private
+        #
+        # Implements sampling based on a probability.
+        class TraceIdRatioBased
+          attr_reader :description
+
+          def initialize(probability)
+            @probability = probability
+            @id_upper_bound = (probability * (2**64 - 1)).ceil
+            @description = format('TraceIdRatioBased{%.6f}', probability)
+          end
+
+          # @api private
+          #
+          # See {Samplers}.
+          def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+            # Ignored for sampling decision: parent_context:, links, name, kind, attributes.
+
+            if sample?(trace_id)
+              RECORD_AND_SAMPLED
+            else
+              NOT_RECORD
+            end
+          end
+
+          private
+
+          def sample?(trace_id)
+            @probability == 1.0 || trace_id[8, 8].unpack1('Q>') < @id_upper_bound
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -18,10 +18,10 @@ module OpenTelemetry
       class Span < OpenTelemetry::Trace::Span
         # The following readers are intended for the use of SpanProcessors and
         # should not be considered part of the public interface for instrumentation.
-        attr_reader :name, :status, :kind, :parent_span_id, :start_timestamp, :end_timestamp, :links, :library_resource, :instrumentation_library
+        attr_reader :name, :status, :kind, :parent_span_id, :start_timestamp, :end_timestamp, :links, :resource, :instrumentation_library
 
         # Return a frozen copy of the current attributes. This is intended for
-        # use of SpanProcesses and should not be considered part of the public
+        # use of SpanProcessors and should not be considered part of the public
         # interface for instrumentation.
         #
         # @return [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}] may be nil.
@@ -59,7 +59,7 @@ module OpenTelemetry
         # meanings.
         #
         # @param [String] key
-        # @param [String, Boolean, Numeric] value
+        # @param [String, Boolean, Numeric, Array<String, Numeric, Boolean>] value
         #
         # @return [self] returns itself
         def set_attribute(key, value)
@@ -76,37 +76,29 @@ module OpenTelemetry
           end
           self
         end
+        alias []= set_attribute
 
-        # Add an Event to a {Span}. This can be accomplished eagerly or lazily.
-        # Lazy evaluation is useful when the event attributes are expensive to
-        # build and where the cost can be avoided for an unsampled {Span}.
+        # Add an Event to a {Span}.
         #
-        # Eager example:
+        # Example:
         #
-        #   span.add_event(name: 'event', attributes: {'eager' => true})
-        #
-        # Lazy example:
-        #
-        #   span.add_event { OpenTelemetry::Trace::Event.new(name: 'event', attributes: {'eager' => false}) }
+        #   span.add_event('event', attributes: {'eager' => true})
         #
         # Note that the OpenTelemetry project
         # {https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/data-semantic-conventions.md
         # documents} certain "standard event names and keys" which have
         # prescribed semantic meanings.
         #
-        # @param [optional String] name Optional name of the event. This is
-        #   required if a block is not given.
+        # @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. This argument should
-        #   only be used when passing in a name.
+        #   values may be string, boolean or numeric type.
         # @param [optional Time] timestamp Optional timestamp for the event.
-        #   This argument should only be used when passing in a name.
         #
         # @return [self] returns itself
-        def add_event(name: nil, attributes: nil, timestamp: nil)
+        def add_event(name, attributes: nil, timestamp: nil)
           super
-          event = block_given? ? yield : OpenTelemetry::Trace::Event.new(name: name, attributes: attributes, timestamp: timestamp || Time.now)
+          event = Event.new(name: name, attributes: attributes, timestamp: timestamp || Time.now)
 
           @mutex.synchronize do
             if @ended
@@ -120,18 +112,18 @@ module OpenTelemetry
           self
         end
 
-        # Record an error during the execution of this span. Multiple errors
+        # Record an exception during the execution of this span. Multiple exceptions
         # can be recorded on a span.
         #
-        # @param [Exception] error The error to be recorded
+        # @param [Exception] exception The exception to be recorded
         #
         # @return [void]
-        def record_error(error)
-          add_event(name: 'error',
+        def record_exception(exception)
+          add_event('exception',
                     attributes: {
-                      'error.type' => error.class.to_s,
-                      'error.message' => error.message,
-                      'error.stack' => error.backtrace.join("\n")
+                      'exception.type' => exception.class.to_s,
+                      'exception.message' => exception.message,
+                      'exception.stacktrace' => exception.full_message(highlight: false, order: :top)
                     })
         end
 
@@ -236,7 +228,7 @@ module OpenTelemetry
             @attributes,
             @links,
             @events,
-            @library_resource,
+            @resource,
             @instrumentation_library,
             context.span_id,
             context.trace_id,
@@ -246,7 +238,7 @@ module OpenTelemetry
         end
 
         # @api private
-        def initialize(context, name, kind, parent_span_id, trace_config, span_processor, attributes, links, start_timestamp, library_resource, instrumentation_library) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        def initialize(context, name, kind, parent_span_id, trace_config, span_processor, attributes, links, start_timestamp, resource, instrumentation_library) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           super(span_context: context)
           @mutex = Mutex.new
           @name = name
@@ -254,7 +246,7 @@ module OpenTelemetry
           @parent_span_id = parent_span_id.freeze || OpenTelemetry::Trace::INVALID_SPAN_ID
           @trace_config = trace_config
           @span_processor = span_processor
-          @library_resource = library_resource
+          @resource = resource
           @instrumentation_library = instrumentation_library
           @ended = false
           @status = nil
@@ -325,7 +317,7 @@ module OpenTelemetry
             attrs.keep_if { |key, value| Internal.valid_key?(key) && Internal.valid_value?(value) }
             excess = attrs.size - max_attributes_per_event
             excess.times { attrs.shift } if excess.positive?
-            event = OpenTelemetry::Trace::Event.new(name: event.name, attributes: attrs, timestamp: event.timestamp)
+            event = Event.new(name: event.name, attributes: attrs, timestamp: event.timestamp)
           end
           events << event
         end

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

@@ -23,12 +23,26 @@ module OpenTelemetry
                             :attributes,
                             :links,
                             :events,
-                            :library_resource,
+                            :resource,
                             :instrumentation_library,
                             :span_id,
                             :trace_id,
                             :trace_flags,
-                            :tracestate)
+                            :tracestate) do
+                              # Returns the lowercase [hex encoded](https://tools.ietf.org/html/rfc4648#section-8) span ID.
+                              #
+                              # @return [String] A 16-hex-character lowercase string.
+                              def hex_span_id
+                                span_id.unpack1('H*')
+                              end
+
+                              # Returns the lowercase [hex encoded](https://tools.ietf.org/html/rfc4648#section-8) trace ID.
+                              #
+                              # @return [String] A 32-hex-character lowercase string.
+                              def hex_trace_id
+                                trace_id.unpack1('H*')
+                              end
+                            end
     end
   end
 end

data/lib/opentelemetry/sdk/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-sdk
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-21 00:00:00.000000000 Z
+date: 2020-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -149,10 +149,10 @@ 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/correlation_context.rb
-- lib/opentelemetry/sdk/correlation_context/builder.rb
-- lib/opentelemetry/sdk/correlation_context/manager.rb
 - lib/opentelemetry/sdk/instrumentation_library.rb
 - lib/opentelemetry/sdk/internal.rb
 - lib/opentelemetry/sdk/resources.rb
@@ -161,6 +161,7 @@ files:
 - lib/opentelemetry/sdk/trace.rb
 - lib/opentelemetry/sdk/trace/config.rb
 - lib/opentelemetry/sdk/trace/config/trace_config.rb
+- lib/opentelemetry/sdk/trace/event.rb
 - lib/opentelemetry/sdk/trace/export.rb
 - lib/opentelemetry/sdk/trace/export/batch_span_processor.rb
 - lib/opentelemetry/sdk/trace/export/console_span_exporter.rb
@@ -173,9 +174,9 @@ files:
 - lib/opentelemetry/sdk/trace/samplers.rb
 - lib/opentelemetry/sdk/trace/samplers/constant_sampler.rb
 - lib/opentelemetry/sdk/trace/samplers/decision.rb
-- lib/opentelemetry/sdk/trace/samplers/parent_or_else.rb
-- lib/opentelemetry/sdk/trace/samplers/probability_sampler.rb
+- lib/opentelemetry/sdk/trace/samplers/parent_based.rb
 - lib/opentelemetry/sdk/trace/samplers/result.rb
+- lib/opentelemetry/sdk/trace/samplers/trace_id_ratio_based.rb
 - lib/opentelemetry/sdk/trace/span.rb
 - lib/opentelemetry/sdk/trace/span_data.rb
 - lib/opentelemetry/sdk/trace/tracer.rb
@@ -200,7 +201,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A stats collection and distributed tracing framework

data/lib/opentelemetry/sdk/correlation_context.rb

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

data/lib/opentelemetry/sdk/trace/samplers/parent_or_else.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Trace
-      module Samplers
-        # @api private
-        #
-        # This is a composite sampler. It either respects the parent span's sampling
-        # decision or delegates to delegate_sampler for root spans.
-        class ParentOrElse
-          def initialize(delegate_sampler)
-            @delegate_sampler = delegate_sampler
-          end
-
-          # @api private
-          #
-          # See {Samplers}.
-          def description
-            "ParentOrElse{#{@delegate_sampler.description}}"
-          end
-
-          # @api private
-          #
-          # See {Samplers}.
-          def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
-            if parent_context.nil?
-              @delegate_sampler.should_sample?(trace_id: trace_id, parent_context: parent_context, links: links, name: name, kind: kind, attributes: attributes)
-            elsif parent_context.trace_flags.sampled?
-              RECORD_AND_SAMPLED
-            else
-              NOT_RECORD
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/sdk/trace/samplers/probability_sampler.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright 2019 OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module SDK
-    module Trace
-      module Samplers
-        # @api private
-        #
-        # Implements sampling based on a probability.
-        class ProbabilitySampler
-          attr_reader :description
-
-          def initialize(probability, ignore_parent:, apply_to_remote_parent:, apply_to_all_spans:)
-            @probability = probability
-            @id_upper_bound = (probability * (2**64 - 1)).ceil
-            @use_parent_sampled_flag = !ignore_parent
-            @apply_to_remote_parent = apply_to_remote_parent
-            @apply_to_all_spans = apply_to_all_spans
-            @description = format('ProbabilitySampler{%.6f}', probability)
-          end
-
-          # @api private
-          #
-          # See {Samplers}.
-          def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
-            # Ignored for sampling decision: links, name, kind, attributes.
-
-            if sample?(trace_id, parent_context)
-              RECORD_AND_SAMPLED
-            else
-              NOT_RECORD
-            end
-          end
-
-          private
-
-          def sample?(trace_id, parent_context)
-            if parent_context.nil?
-              sample_trace_id?(trace_id)
-            else
-              parent_sampled?(parent_context) || sample_trace_id_for_child?(parent_context, trace_id)
-            end
-          end
-
-          def parent_sampled?(parent_context)
-            @use_parent_sampled_flag && parent_context.trace_flags.sampled?
-          end
-
-          def sample_trace_id_for_child?(parent_context, trace_id)
-            (@apply_to_all_spans || (@apply_to_remote_parent && parent_context.remote?)) && sample_trace_id?(trace_id)
-          end
-
-          def sample_trace_id?(trace_id)
-            @probability == 1.0 || trace_id[8, 8].unpack1('Q>') < @id_upper_bound
-          end
-        end
-      end
-    end
-  end
-end