opentelemetry-sdk 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb002eea7584e4788afaee003a24012aa93582788ecd8745d6e0979d6a80970c
-  data.tar.gz: f8b5037249031a315436a24eb28235e1cab63915a57ebaab5493784cc6116cfc
+  metadata.gz: 1929c4e29a936b51b4f2eca8ec7b4e2f7a597e43e72039e6e963aa72cd00f65f
+  data.tar.gz: cbf9a0ade97c3dab0a8005cf84729ab8d549c6f0768ea9446d8a71585d676d4f
 SHA512:
-  metadata.gz: 03036bff46744fd6670649fea70300cff02e5364a19449bf38fe8ebfde7c5f5b831bfda12fcae685028469ecc6d7367e9b46125e247e7f5c2b0f8688ddb66b81
-  data.tar.gz: 2f4e11052927da389fd45d7dd0d173e51eec3e8818ad4dba962f6ef42e3b9bdeda414e0f2517c6c429069607d3e4114dc4f7a6b9126c0190fd26d0a40ac4c030
+  metadata.gz: de2f88ace625de9e494a6800291462330c58d12e0ecac2e8a7a184a8c34382557639aea59eea3dbf16a603355c604446e00cd2b9fe8f2ad3cb009f21c68186cb
+  data.tar.gz: 42342b8cee795fd241a650b2abae0b8f3f4f73a202605bdcce6ec861de5fe53325fc3e273fe8c06e386df4b42a76ab3d0667990a502f31a0636de733f62b2aef

data/lib/opentelemetry/sdk.rb

@@ -30,13 +30,13 @@ module OpenTelemetry
     #   Install instrumentation individually with optional config
     #
     #     OpenTelemetry::SDK.configure do |c|
-    #       c.use 'OpenTelemetry::Adapters::Faraday', tracer_middleware: SomeMiddleware
+    #       c.use 'OpenTelemetry::Instrumentation::Faraday', tracer_middleware: SomeMiddleware
     #     end
     #
     #   Install all instrumentation with optional config
     #
     #     OpenTelemetry::SDK.configure do |c|
-    #       c.use_all 'OpenTelemetry::Adapters::Faraday' => { tracer_middleware: SomeMiddleware }
+    #       c.use_all 'OpenTelemetry::Instrumentation::Faraday' => { tracer_middleware: SomeMiddleware }
     #     end
     #
     #   Add a span processor
@@ -63,6 +63,7 @@ end
 require 'opentelemetry/sdk/configurator'
 require 'opentelemetry/sdk/correlation_context'
 require 'opentelemetry/sdk/internal'
+require 'opentelemetry/sdk/instrumentation_library'
 require 'opentelemetry/sdk/resources'
 require 'opentelemetry/sdk/trace'
 require 'opentelemetry/sdk/version'

data/lib/opentelemetry/sdk/configurator.rb

@@ -8,7 +8,7 @@ module OpenTelemetry
   module SDK
     # The configurator provides defaults and facilitates configuring the
     # SDK for use.
-    class Configurator
+    class Configurator # rubocop:disable Metrics/ClassLength
       USE_MODE_UNSPECIFIED = 0
       USE_MODE_ONE = 1
       USE_MODE_ALL = 2
@@ -19,46 +19,55 @@ module OpenTelemetry
                   :text_injectors
 
       def initialize
-        @adapter_names = []
-        @adapter_config_map = {}
+        @instrumentation_names = []
+        @instrumentation_config_map = {}
         @http_extractors = nil
         @http_injectors = nil
         @text_extractors = nil
         @text_injectors = nil
         @span_processors = []
         @use_mode = USE_MODE_UNSPECIFIED
-        @tracer_provider = Trace::TracerProvider.new
+        @resource = Resources::Resource.telemetry_sdk
       end
 
       def logger
         @logger ||= Logger.new(STDOUT)
       end
 
-      # Install an instrumentation adapter with specificied optional +config+.
-      # Use can be called multiple times to install multiple instrumentation
-      # adapters. Only +use+ or +use_all+, but not both when installing
+      # 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.
+      #
+      # @param [Resource] new_resource The resource to be merged
+      def resource=(new_resource)
+        @resource = @resource.merge(new_resource)
+      end
+
+      # Install an instrumentation with specificied optional +config+.
+      # Use can be called multiple times to install multiple instrumentation.
+      # Only +use+ or +use_all+, but not both when installing
       # instrumentation. A call to +use_all+ after +use+ will result in an
       # exception.
       #
-      # @param [String] adapter_name The name of the instrumentation adapter
-      # @param [optional Hash] config The config for this adapter
-      def use(adapter_name, config = nil)
+      # @param [String] instrumentation_name The name of the instrumentation
+      # @param [optional Hash] config The config for this instrumentation
+      def use(instrumentation_name, config = nil)
         check_use_mode!(USE_MODE_ONE)
-        @adapter_names << adapter_name
-        @adapter_config_map[adapter_name] = config if config
+        @instrumentation_names << instrumentation_name
+        @instrumentation_config_map[instrumentation_name] = config if config
       end
 
       # Install all registered instrumentation. Configuration for specific
-      # adapters can be provided with the optional +adapter_config_map+
+      # instrumentation can be provided with the optional +instrumentation_config_map+
       # parameter. Only +use+ or +use_all+, but not both when installing
       # instrumentation. A call to +use+ after +use_all+ will result in an
       # exception.
       #
-      # @param [optional Hash<String,Hash>] adapter_config_map A map with string keys
-      #   representing the adapter name and values specifying the adapter config
-      def use_all(adapter_config_map = {})
+      # @param [optional Hash<String,Hash>] instrumentation_config_map A map with string keys
+      #   representing the instrumentation name and values specifying the instrumentation config
+      def use_all(instrumentation_config_map = {})
         check_use_mode!(USE_MODE_ALL)
-        @adapter_config_map = adapter_config_map
+        @instrumentation_config_map = instrumentation_config_map
       end
 
       # Add a span processor to the export pipeline
@@ -83,12 +92,16 @@ module OpenTelemetry
         OpenTelemetry.correlations = CorrelationContext::Manager.new
         configure_propagation
         configure_span_processors
-        OpenTelemetry.tracer_provider = @tracer_provider
+        OpenTelemetry.tracer_provider = tracer_provider
         install_instrumentation
       end
 
       private
 
+      def tracer_provider
+        @tracer_provider ||= Trace::TracerProvider.new(@resource)
+      end
+
       def check_use_mode!(mode)
         @use_mode = mode if @use_mode == USE_MODE_UNSPECIFIED
         raise 'Use either `use_all` or `use`, but not both' unless @use_mode == mode
@@ -97,15 +110,15 @@ module OpenTelemetry
       def install_instrumentation
         case @use_mode
         when USE_MODE_ONE
-          OpenTelemetry.instrumentation_registry.install(@adapter_names, @adapter_config_map)
+          OpenTelemetry.instrumentation_registry.install(@instrumentation_names, @instrumentation_config_map)
         when USE_MODE_ALL
-          OpenTelemetry.instrumentation_registry.install_all(@adapter_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.each { |p| @tracer_provider.add_span_processor(p) }
+        processors.each { |p| tracer_provider.add_span_processor(p) }
       end
 
       def default_span_processor

data/lib/opentelemetry/sdk/correlation_context.rb

@@ -9,7 +9,7 @@ require 'opentelemetry/sdk/correlation_context/manager'
 
 module OpenTelemetry
   module SDK
-    # Contains operational implementataions of the CorrelationContext::Manager
+    # Contains operational implementations of the CorrelationContext::Manager
     module CorrelationContext
     end
   end

data/lib/opentelemetry/sdk/instrumentation_library.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    # InstrumentationLibrary is a struct containing library information for export.
+    InstrumentationLibrary = Struct.new(:name,
+                                        :version)
+  end
+end

data/lib/opentelemetry/sdk/resources.rb

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

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+# Copyright 2020 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 namespace that the pod is running in.
+          namespace_name: 'k8s.namespace.name',
+
+          # The name of the pod.
+          pod_name: 'k8s.pod.name',
+
+          # The name of the deployment.
+          deployment_name: 'k8s.deployment.name'
+        }.freeze
+
+        # Attributes defining a computing instance (e.g. host).
+        HOST_RESOURCE = {
+          # Hostname of the host. It contains what the hostname command returns on the
+          # host machine.
+          hostname: 'host.hostname',
+
+          # 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',
+
+          # Zones are a sub set of the region connected through low-latency links.
+          zone: 'cloud.zone'
+        }.freeze
+      end
+    end
+  end
+end

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

@@ -29,6 +29,14 @@ module OpenTelemetry
 
             new(frozen_labels)
           end
+
+          def telemetry_sdk
+            create(
+              Constants::TELEMETRY_SDK_RESOURCE[:name] => 'opentelemetry',
+              Constants::TELEMETRY_SDK_RESOURCE[:language] => 'ruby',
+              Constants::TELEMETRY_SDK_RESOURCE[:version] => "semver:#{OpenTelemetry::SDK::VERSION}"
+            )
+          end
         end
 
         # @api private

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

@@ -15,13 +15,8 @@ module OpenTelemetry
         # The export operation finished successfully.
         SUCCESS = 0
 
-        # The export operation finished with an error, but retrying may
-        # succeed.
-        FAILED_RETRYABLE = 1
-
-        # The export operation finished with an error, the caller should not
-        # try to export the same data again.
-        FAILED_NOT_RETRYABLE = 2
+        # The export operation finished with an error.
+        FAILURE = 1
       end
     end
   end

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

@@ -22,24 +22,18 @@ module OpenTelemetry
         # If the queue gets half full a preemptive notification is sent to the
         # worker thread that exports the spans to wake up and start a new
         # export cycle.
-        #
-        # max_export_attempts attempts are made to export each batch, while
-        # export fails with {FAILED_RETRYABLE}, backing off linearly in 100ms
-        # increments.
         class BatchSpanProcessor
           EXPORTER_TIMEOUT_MILLIS = 30_000
           SCHEDULE_DELAY_MILLIS = 5_000
           MAX_QUEUE_SIZE = 2048
           MAX_EXPORT_BATCH_SIZE = 512
-          MAX_EXPORT_ATTEMPTS = 5
-          private_constant(:SCHEDULE_DELAY_MILLIS, :MAX_QUEUE_SIZE, :MAX_EXPORT_BATCH_SIZE, :MAX_EXPORT_ATTEMPTS)
+          private_constant(:SCHEDULE_DELAY_MILLIS, :MAX_QUEUE_SIZE, :MAX_EXPORT_BATCH_SIZE)
 
           def initialize(exporter:,
                          exporter_timeout_millis: EXPORTER_TIMEOUT_MILLIS,
                          schedule_delay_millis: SCHEDULE_DELAY_MILLIS,
                          max_queue_size: MAX_QUEUE_SIZE,
-                         max_export_batch_size: MAX_EXPORT_BATCH_SIZE,
-                         max_export_attempts: MAX_EXPORT_ATTEMPTS)
+                         max_export_batch_size: MAX_EXPORT_BATCH_SIZE)
             raise ArgumentError if max_export_batch_size > max_queue_size
 
             @exporter = exporter
@@ -50,7 +44,6 @@ module OpenTelemetry
             @delay_seconds = schedule_delay_millis / 1000.0
             @max_queue_size = max_queue_size
             @batch_size = max_export_batch_size
-            @export_attempts = max_export_attempts
             @spans = []
             @thread = Thread.new { work }
           end
@@ -121,20 +114,14 @@ module OpenTelemetry
           end
 
           def export_batch(batch)
-            result_code = nil
-            @export_attempts.times do |attempts|
-              result_code = export_with_timeout(batch)
-              break unless result_code == FAILED_RETRYABLE
-
-              sleep(0.1 * attempts)
-            end
+            result_code = export_with_timeout(batch)
             report_result(result_code, batch)
           end
 
           def export_with_timeout(batch)
             Timeout.timeout(@exporter_timeout_seconds) { @exporter.export(batch) }
           rescue Timeout::Error
-            FAILED_NOT_RETRYABLE
+            FAILURE
           end
 
           def report_result(result_code, batch)

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

@@ -23,7 +23,7 @@ module OpenTelemetry
           end
 
           def export(spans)
-            return ResultCodes::FAILED_NOT_RETRYABLE if @stopped
+            return ResultCodes::FAILURE if @stopped
 
             Array(spans).each { |s| pp s }
 

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

@@ -61,10 +61,10 @@ module OpenTelemetry
           # @param [Enumerable<SpanData>] span_datas the list of sampled {SpanData}s to be
           #   exported.
           # @return [Integer] the result of the export, SUCCESS or
-          #   FAILED_NOT_RETRYABLE
+          #   FAILURE
           def export(span_datas)
             @mutex.synchronize do
-              return FAILED_NOT_RETRYABLE if @stopped
+              return FAILURE if @stopped
 
               @finished_spans.concat(span_datas.to_a)
             end

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

@@ -29,7 +29,7 @@ module OpenTelemetry
               merge_result_code(result_code, span_exporter.export(spans))
             rescue => e # rubocop:disable Style/RescueStandardError
               OpenTelemetry.logger.warn("exception raised by export - #{e}")
-              FAILED_NOT_RETRYABLE
+              FAILURE
             end
           end
 
@@ -46,13 +46,9 @@ module OpenTelemetry
             if result_code == SUCCESS && new_result_code == SUCCESS
               # If both errors are success then return success.
               SUCCESS
-            elsif result_code == FAILED_NOT_RETRYABLE || new_result_code == FAILED_NOT_RETRYABLE
-              # If any of the codes is not retryable then return not_retryable.
-              FAILED_NOT_RETRYABLE
             else
-              # At this point at least one of the code is FAILED_RETRYABLE and
-              # none are FAILED_NOT_RETRYABLE, so return FAILED_RETRYABLE.
-              FAILED_RETRYABLE
+              # At this point at least one of the code is FAILURE, so return FAILURE.
+              FAILURE
             end
           end
         end

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

@@ -27,7 +27,7 @@ module OpenTelemetry
           def export(spans)
             return SUCCESS unless @stopped
 
-            FAILED_NOT_RETRYABLE
+            FAILURE
           end
 
           # Called when {TracerProvider#shutdown} is called, if this exporter is

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

@@ -6,6 +6,8 @@
 
 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'
 
 module OpenTelemetry
@@ -13,17 +15,16 @@ module OpenTelemetry
     module Trace
       # The Samplers module contains the sampling logic for OpenTelemetry. The
       # reference implementation provides a {ProbabilitySampler}, {ALWAYS_ON},
-      # {ALWAYS_OFF}, and {ALWAYS_PARENT}.
+      # {ALWAYS_OFF}, and {ParentOrElse}.
       #
-      # Custom samplers can be provided by SDK users. The required interface is
-      # a callable with the signature:
+      # Custom samplers can be provided by SDK users. The required interface is:
       #
-      #   (trace_id:, span_id:, parent_context:, links:, name:, kind:, attributes:) -> Result
+      #   should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:) -> Result
+      #   description -> String
       #
       # Where:
       #
       # @param [String] trace_id The trace_id of the {Span} to be created.
-      # @param [String] span_id The span_id of the {Span} to be created.
       # @param [OpenTelemetry::Trace::SpanContext] parent_context The
       #   {OpenTelemetry::Trace::SpanContext} of a parent span, typically
       #   extracted from the wire. Can be nil for a root span.
@@ -44,27 +45,20 @@ module OpenTelemetry
 
         private_constant(:RECORD_AND_SAMPLED, :NOT_RECORD, :RECORD, :SAMPLING_HINTS, :APPLY_PROBABILITY_TO_SYMBOLS)
 
-        # rubocop:disable Lint/UnusedBlockArgument
-
         # Returns a {Result} with {Decision::RECORD_AND_SAMPLED}.
-        ALWAYS_ON = ->(trace_id:, span_id:, parent_context:, links:, name:, kind:, attributes:) { RECORD_AND_SAMPLED }
+        ALWAYS_ON = ConstantSampler.new(result: RECORD_AND_SAMPLED, description: 'AlwaysOnSampler')
 
         # Returns a {Result} with {Decision::NOT_RECORD}.
-        ALWAYS_OFF = ->(trace_id:, span_id:, parent_context:, links:, name:, kind:, attributes:) { NOT_RECORD }
+        ALWAYS_OFF = ConstantSampler.new(result: NOT_RECORD, description: 'AlwaysOffSampler')
 
-        # Returns a {Result} with {Decision::RECORD_AND_SAMPLED} if the parent
-        # context is sampled or {Decision::NOT_RECORD} otherwise, or if there
-        # is no parent context.
-        # rubocop:disable Style/Lambda
-        ALWAYS_PARENT = ->(trace_id:, span_id:, parent_context:, links:, name:, kind:, attributes:) do
-          if parent_context&.trace_flags&.sampled?
-            RECORD_AND_SAMPLED
-          else
-            NOT_RECORD
-          end
+        # Returns a new sampler. It either respects the parent span's sampling
+        # decision or delegates to delegate_sampler for root spans.
+        #
+        # @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)
         end
-        # rubocop:enable Style/Lambda
-        # rubocop:enable Lint/UnusedBlockArgument
 
         # Returns a new sampler. The probability of sampling a trace is equal
         # to that of the specified probability.

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module SDK
+    module Trace
+      module Samplers
+        # @api private
+        #
+        # Implements a sampler returning a constant result.
+        class ConstantSampler
+          attr_reader :description
+
+          def initialize(result:, description:)
+            @result = result
+            @description = description
+          end
+
+          # @api private
+          #
+          # See {Samplers}.
+          def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+            # All arguments ignored for sampling decision.
+            @result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# 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

@@ -12,18 +12,21 @@ module OpenTelemetry
         #
         # 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 = format('%016x', (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
           #
-          # Callable interface for probability sampler. See {Samplers}.
-          def call(trace_id:, span_id:, parent_context:, links:, name:, kind:, attributes:)
+          # 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)

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

@@ -18,7 +18,7 @@ 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
+        attr_reader :name, :status, :kind, :parent_span_id, :start_timestamp, :end_timestamp, :links, :library_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
@@ -237,14 +237,16 @@ module OpenTelemetry
             @links,
             @events,
             @library_resource,
+            @instrumentation_library,
             context.span_id,
             context.trace_id,
-            context.trace_flags
+            context.trace_flags,
+            context.tracestate
           )
         end
 
         # @api private
-        def initialize(context, name, kind, parent_span_id, trace_config, span_processor, attributes, links, start_timestamp, library_resource) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        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
           super(span_context: context)
           @mutex = Mutex.new
           @name = name
@@ -253,6 +255,7 @@ module OpenTelemetry
           @trace_config = trace_config
           @span_processor = span_processor
           @library_resource = library_resource
+          @instrumentation_library = instrumentation_library
           @ended = false
           @status = nil
           @child_count = 0

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

@@ -24,9 +24,11 @@ module OpenTelemetry
                             :links,
                             :events,
                             :library_resource,
+                            :instrumentation_library,
                             :span_id,
                             :trace_id,
-                            :trace_flags)
+                            :trace_flags,
+                            :tracestate)
     end
   end
 end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright 2019 OpenTelemetry Authors
+# Copyright 2020 OpenTelemetry Authors
 #
 # SPDX-License-Identifier: Apache-2.0
 
@@ -11,6 +11,7 @@ module OpenTelemetry
       class Tracer < OpenTelemetry::Trace::Tracer
         attr_reader :name
         attr_reader :version
+        attr_reader :tracer_provider
 
         # @api private
         #
@@ -18,12 +19,14 @@ module OpenTelemetry
         #
         # @param [String] name Instrumentation package name
         # @param [String] version Instrumentation package version
+        # @param [TracerProvider] tracer_provider TracerProvider that initialized the tracer
         #
         # @return [Tracer]
-        def initialize(name, version)
+        def initialize(name, version, tracer_provider)
           @name = name
           @version = version
-          @resource = Resources::Resource.create('name' => name, 'version' => version)
+          @instrumentation_library = InstrumentationLibrary.new(name, version)
+          @tracer_provider = tracer_provider
         end
 
         def start_root_span(name, attributes: nil, links: nil, start_timestamp: nil, kind: nil)
@@ -40,22 +43,31 @@ module OpenTelemetry
           trace_id = parent_span_context&.trace_id
           trace_id ||= OpenTelemetry::Trace.generate_trace_id
           span_id = OpenTelemetry::Trace.generate_span_id
-          sampler = OpenTelemetry.tracer_provider.active_trace_config.sampler
-          result = sampler.call(trace_id: trace_id, span_id: span_id, parent_context: parent_span_context, links: links, name: name, kind: kind, attributes: attributes)
-
+          sampler = tracer_provider.active_trace_config.sampler
+          result = sampler.should_sample?(trace_id: trace_id, parent_context: parent_span_context, links: links, name: name, kind: kind, attributes: attributes)
           internal_create_span(result, name, kind, trace_id, span_id, parent_span_id, attributes, links, start_timestamp, tracestate)
         end
 
         private
 
         def internal_create_span(result, name, kind, trace_id, span_id, parent_span_id, attributes, links, start_timestamp, tracestate) # rubocop:disable Metrics/AbcSize
-          if result.recording? && !OpenTelemetry.tracer_provider.stopped?
+          if result.recording? && !tracer_provider.stopped?
             trace_flags = result.sampled? ? OpenTelemetry::Trace::TraceFlags::SAMPLED : OpenTelemetry::Trace::TraceFlags::DEFAULT
             context = OpenTelemetry::Trace::SpanContext.new(trace_id: trace_id, trace_flags: trace_flags, tracestate: tracestate)
             attributes = attributes&.merge(result.attributes) || result.attributes
-            active_trace_config = OpenTelemetry.tracer_provider.active_trace_config
-            active_span_processor = OpenTelemetry.tracer_provider.active_span_processor
-            Span.new(context, name, kind, parent_span_id, active_trace_config, active_span_processor, attributes, links, start_timestamp || Time.now, @resource)
+            Span.new(
+              context,
+              name,
+              kind,
+              parent_span_id,
+              tracer_provider.active_trace_config,
+              tracer_provider.active_span_processor,
+              attributes,
+              links,
+              start_timestamp || Time.now,
+              tracer_provider.resource,
+              @instrumentation_library
+            )
           else
             OpenTelemetry::Trace::Span.new(span_context: OpenTelemetry::Trace::SpanContext.new(trace_id: trace_id))
           end

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

@@ -13,20 +13,20 @@ module OpenTelemetry
         private_constant(:Key)
 
         attr_accessor :active_trace_config
-        attr_reader :active_span_processor
-        attr_reader :stopped
+        attr_reader :active_span_processor, :stopped, :resource
         alias stopped? stopped
 
         # Returns a new {TracerProvider} instance.
         #
         # @return [TracerProvider]
-        def initialize
+        def initialize(resource = OpenTelemetry::SDK::Resources::Resource.create)
           @mutex = Mutex.new
           @registry = {}
           @active_span_processor = NoopSpanProcessor.instance
           @active_trace_config = Config::TraceConfig::DEFAULT
           @registered_span_processors = []
           @stopped = false
+          @resource = resource
         end
 
         # Returns a {Tracer} instance.
@@ -38,7 +38,7 @@ module OpenTelemetry
         def tracer(name = nil, version = nil)
           name ||= ''
           version ||= ''
-          @mutex.synchronize { @registry[Key.new(name, version)] ||= Tracer.new(name, version) }
+          @mutex.synchronize { @registry[Key.new(name, version)] ||= Tracer.new(name, version, self) }
         end
 
         # Attempts to stop all the activity for this {Tracer}. Calls

data/lib/opentelemetry/sdk/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-sdk
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-16 00:00:00.000000000 Z
+date: 2020-07-17 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.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -153,8 +153,10 @@ files:
 - 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
+- lib/opentelemetry/sdk/resources/constants.rb
 - lib/opentelemetry/sdk/resources/resource.rb
 - lib/opentelemetry/sdk/trace.rb
 - lib/opentelemetry/sdk/trace/config.rb
@@ -169,7 +171,9 @@ files:
 - lib/opentelemetry/sdk/trace/multi_span_processor.rb
 - lib/opentelemetry/sdk/trace/noop_span_processor.rb
 - 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/result.rb
 - lib/opentelemetry/sdk/trace/span.rb