opentelemetry-api 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d08aa373b1b789dfeaa4541beb9c6cc77f5338a1fd8031a33c6ab7d9e68fc228
-  data.tar.gz: f93c6d644183106c76eae7920fd0dc51fba1bcc7ab15dfab1ed55dab0b0e48df
+  metadata.gz: 1615af5677eaafab347128c1c887cbcc9aae43216b3d14705e3ac4e1e0f19813
+  data.tar.gz: 8476d0abf68fd2cd2ed9fd5a688b6e70cdf0dc039f4a53216a9086361a069959
 SHA512:
-  metadata.gz: 69f567cc86c5d6be5a6e6ba6b777bfff01277bfcaf417c8130c32b237ee2596aa94963dc08d22a843683deff6de67fd90a7902f48894044d9f912e82bbb8ae43
-  data.tar.gz: 26dfc71e399df415210cad456ccbf2e6f8848161eb1a3bc77a0b3180eb94c07fc7447bb8128bb8d3ea11ecb52ce29038435b0c09e8337d9c31036ab574f87f7f
+  metadata.gz: f68b6dde83c283f935bad1ef35ac2ce8add945be714b249b01bbfcb8d0fd17c2afdb97b499a463112eb0929247ba362f4cca464f54b1277ebf693b32bf23750f
+  data.tar.gz: bd3756833a94fed1d20a7de3eabdd65d59157eef045dcce359ec5811796b4468d6ba23b1f05973293dd0c8939e6b9ace4dbcc0ca94c482b81dcddcb006df0ec6

data/lib/opentelemetry/correlation_context/propagation.rb

@@ -18,10 +18,10 @@ module OpenTelemetry
       TEXT_EXTRACTOR = TextExtractor.new
       TEXT_INJECTOR = TextInjector.new
       RACK_EXTRACTOR = TextExtractor.new(
-        correlation_context_key: 'HTTP_CORRELATION_CONTEXT'
+        correlation_context_key: 'HTTP_OTCORRELATIONS'
       )
       RACK_INJECTOR = TextInjector.new(
-        correlation_context_key: 'HTTP_CORRELATION_CONTEXT'
+        correlation_context_key: 'HTTP_OTCORRELATIONS'
       )
 
       private_constant :TEXT_INJECTOR, :TEXT_EXTRACTOR, :RACK_INJECTOR,

data/lib/opentelemetry/correlation_context/propagation/text_extractor.rb

@@ -19,7 +19,7 @@ module OpenTelemetry
         # @param [String] correlation_context_key The correlation context header
         #   key used in the carrier
         # @return [TextExtractor]
-        def initialize(correlation_context_key: 'Correlation-Context')
+        def initialize(correlation_context_key: 'otcorrelations')
           @correlation_context_key = correlation_context_key
         end
 

data/lib/opentelemetry/correlation_context/propagation/text_injector.rb

@@ -19,7 +19,7 @@ module OpenTelemetry
         # @param [String] correlation_context_header_key The correlation context header
         #   key used in the carrier
         # @return [TextInjector]
-        def initialize(correlation_context_key: 'Correlation-Context')
+        def initialize(correlation_context_key: 'otcorrelations')
           @correlation_context_key = correlation_context_key
         end
 

data/lib/opentelemetry/instrumentation.rb

@@ -5,11 +5,11 @@
 # SPDX-License-Identifier: Apache-2.0
 
 require 'opentelemetry/instrumentation/registry'
-require 'opentelemetry/instrumentation/adapter'
+require 'opentelemetry/instrumentation/base'
 
 module OpenTelemetry
   # The instrumentation module contains functionality to register and install
-  # instrumentation adapters
+  # instrumentation
   module Instrumentation
   end
 end

data/lib/opentelemetry/instrumentation/{adapter.rb → base.rb}

@@ -6,20 +6,20 @@
 
 module OpenTelemetry
   module Instrumentation
-    # The Adapter class holds all metadata and configuration for an
-    # instrumentation adapter. All instrumentation adapter packages should
-    # include a subclass of +Instrumentation::Adapter+ that will register
+    # The Base class holds all metadata and configuration for an
+    # instrumentation. All instrumentation packages should
+    # include a subclass of +Instrumentation::Base+ that will register
     # it with +OpenTelemetry.instrumentation_registry+ and make it available for
     # discovery and installation by an SDK.
     #
-    # A typical subclass of Adapter will provide an install block, a present
+    # A typical subclass of Base will provide an install block, a present
     # block, and possibly a compatible block. Below is an
     # example:
     #
     # module OpenTelemetry
-    #   module Adapters
+    #   module Instrumentation
     #     module Sinatra
-    #       class Adapter < OpenTelemetry::Instrumentation::Adapter
+    #       class Instrumentation < OpenTelemetry::Instrumentation::Base
     #         install do |config|
     #           # install instrumentation, either by library hook or applying
     #           # a monkey patch
@@ -39,27 +39,27 @@ module OpenTelemetry
     #   end
     # end
     #
-    # The adapter name and version will be inferred from the namespace of the
-    # class. In this example, they'd be 'OpenTelemetry::Adapters::Sinatra' and
-    # OpenTelemetry::Adapters::Sinatra::VERSION, but can be explicitly set using
-    # the +adapter_name+ and +adapter_version+ methods if necessary.
+    # The instrumentation name and version will be inferred from the namespace of the
+    # class. In this example, they'd be 'OpenTelemetry::Instrumentation::Sinatra' and
+    # OpenTelemetry::Instrumentation::Sinatra::VERSION, but can be explicitly set using
+    # the +instrumentation_name+ and +instrumetation_version+ methods if necessary.
     #
-    # All subclasses of OpenTelemetry::Instrumentation::Adapter are automatically
+    # All subclasses of OpenTelemetry::Instrumentation::Base are automatically
     # registered with OpenTelemetry.instrumentation_registry which is used by
     # SDKs for instrumentation discovery and installation.
     #
-    # Instrumentation libraries can use the adapter subclass to easily gain
+    # Instrumentation libraries can use the instrumentation subclass to easily gain
     # a reference to its named tracer. For example:
     #
-    # OpenTelemetry::Adapters::Sinatra.instance.tracer
+    # OpenTelemetry::Instrumentation::Sinatra.instance.tracer
     #
-    # The adapter class establishes a convention for disabling an adapter
-    # by environment variable and local configuration. An adapter disabled
+    # The instrumention class establishes a convention for disabling an instrumentation
+    # by environment variable and local configuration. An instrumentation disabled
     # by environment variable will take precedence over local config. The
     # convention for environment variable name is the library name, upcased with
-    # '::' replaced by underscores, and '_ENABLED' appended. For example:
-    # OPENTELEMETRY_ADAPTERS_SINATRA_ENABLED = false.
-    class Adapter
+    # '::' replaced by underscores, OPENTELEMETRY shortened to OTEL_{LANG}, and '_ENABLED' appended.
+    # For example: OTEL_RUBY_INSTRUMENTATION_SINATRA_ENABLED = false.
+    class Base
       class << self
         NAME_REGEX = /^(?:(?<namespace>[a-zA-Z0-9_:]+):{2})?(?<classname>[a-zA-Z0-9_]+)$/.freeze
         private_constant :NAME_REGEX
@@ -70,67 +70,67 @@ module OpenTelemetry
           OpenTelemetry.instrumentation_registry.register(subclass)
         end
 
-        # Optionally set the name of this instrumentation adapter. If not
+        # Optionally set the name of this instrumentation. If not
         # explicitly set, the name will default to the namespace of the class,
         # or the class name if it does not have a namespace. If there is not
         # a namespace, or a class name, it will default to 'unknown'.
         #
-        # @param [String] adapter_name The full name of the adapter package
-        def adapter_name(adapter_name = nil)
-          if adapter_name
-            @adapter_name = adapter_name
+        # @param [String] instrumentation_name The full name of the instrumentation package
+        def instrumentation_name(instrumentation_name = nil)
+          if instrumentation_name
+            @instrumentation_name = instrumentation_name
           else
-            @adapter_name ||= infer_name || 'unknown'
+            @instrumentation_name ||= infer_name || 'unknown'
           end
         end
 
-        # Optionally set the version of this adapter. If not explicitly set,
+        # Optionally set the version of this instrumentation. If not explicitly set,
         # the version will default to the VERSION constant under namespace of
         # the class, or the VERSION constant under the class name if it does not
         # have a namespace. If a VERSION constant cannot be found, it defaults
         # to '0.0.0'.
         #
-        # @param [String] adapter_version The version of the adapter package
-        def adapter_version(adapter_version = nil)
-          if adapter_version
-            @adapter_version = adapter_version
+        # @param [String] instrumentation_version The version of the instrumentation package
+        def instrumentation_version(instrumentation_version = nil)
+          if instrumentation_version
+            @instrumentation_version = instrumentation_version
           else
-            @adapter_version ||= infer_version || '0.0.0'
+            @instrumentation_version ||= infer_version || '0.0.0'
           end
         end
 
-        # The install block for this adapter. This will be where you install
+        # The install block for this instrumentation. This will be where you install
         # instrumentation, either by framework hook or applying a monkey patch.
         #
-        # @param [Callable] blk The install block for this adapter
-        # @yieldparam [Hash] config The adapter config will be yielded to the
+        # @param [Callable] blk The install block for this instrumentation
+        # @yieldparam [Hash] config The instrumentation config will be yielded to the
         #   install block
         def install(&blk)
           @install_blk = blk
         end
 
-        # The present block for this adapter. This block is used to detect if
+        # The present block for this instrumentation. This block is used to detect if
         # target library is present on the system. Typically this will involve
         # checking to see if the target gem spec was loaded or if expected
         # constants from the target library are present.
         #
-        # @param [Callable] blk The present block for this adapter
+        # @param [Callable] blk The present block for this instrumentation
         def present(&blk)
           @present_blk = blk
         end
 
-        # The compatible block for this adapter. This check will be run if the
+        # The compatible block for this instrumentation. This check will be run if the
         # target library is present to determine if it's compatible. It's not
         # required, but a common use case will be to check to target library
         # version for compatibility.
         #
-        # @param [Callable] blk The compatibility block for this adapter
+        # @param [Callable] blk The compatibility block for this instrumentation
         def compatible(&blk)
           @compatible_blk = blk
         end
 
         def instance
-          @instance ||= new(adapter_name, adapter_version, install_blk,
+          @instance ||= new(instrumentation_name, instrumentation_version, install_blk,
                             present_blk, compatible_blk)
         end
 
@@ -171,11 +171,11 @@ module OpenTelemetry
         @installed = false
       end
 
-      # Install adapter with the given config. The present? and compatible?
+      # Install instrumentation with the given config. The present? and compatible?
       # will be run first, and install will return false if either fail. Will
       # return true if install was completed successfully.
       #
-      # @param [Hash] config The config for this adapter
+      # @param [Hash] config The config for this instrumentation
       def install(config = {})
         return true if installed?
         return false unless installable?(config)
@@ -186,24 +186,24 @@ module OpenTelemetry
         @installed = true
       end
 
-      # Whether or not this adapter is installable in the current process. Will
-      # be true when the adapter defines an install block, is not disabled
+      # Whether or not this instrumentation is installable in the current process. Will
+      # be true when the instrumentation defines an install block, is not disabled
       # by environment or config, and the target library present and compatible.
       #
-      # @param [Hash] config The config for this adapter
+      # @param [Hash] config The config for this instrumentation
       def installable?(config = {})
         @install_blk && enabled?(config) && present? && compatible?
       end
 
-      # Calls the present block of the Adapter subclasses, if no block is provided
-      # it's assumed the adapter is not present
+      # Calls the present block of the Instrumentation subclasses, if no block is provided
+      # it's assumed the instrumentation is not present
       def present?
         return false unless @present_blk
 
         instance_exec(&@present_blk)
       end
 
-      # Calls the compatible block of the Adapter subclasses, if no block is provided
+      # Calls the compatible block of the Instrumentation subclasses, if no block is provided
       # it's assumed to be compatible
       def compatible?
         return true unless @compatible_blk
@@ -211,7 +211,7 @@ module OpenTelemetry
         instance_exec(&@compatible_blk)
       end
 
-      # Whether this adapter is enabled. It first checks to see if it's enabled
+      # Whether this instrumentation is enabled. It first checks to see if it's enabled
       # by an environment variable and will proceed to check if it's enabled
       # by local config, if given.
       #
@@ -225,16 +225,17 @@ module OpenTelemetry
 
       private
 
-      # Checks to see if this adapter is enabled by env var. By convention, the
-      # environment variable will be the adapter name upper cased, with '::'
-      # replaced by underscores and _ENABLED appended. For example, the
-      # environment variable name for OpenTelemetry::Adapter::Sinatra will be
-      # OPENTELEMETRY_ADAPTERS_SINATRA_ENABLED. A value of 'false' will disable
-      # the adapter, all other values will enable it.
+      # Checks to see if this instrumentation is enabled by env var. By convention, the
+      # environment variable will be the instrumentation name upper cased, with '::'
+      # replaced by underscores, OPENTELEMETRY shortened to OTEL_{LANG} and _ENABLED appended.
+      # For example, the, environment variable name for OpenTelemetry::Instrumentation::Sinatra
+      # will be OTEL_RUBY_INSTRUMENTATION_SINATRA_ENABLED. A value of 'false' will disable
+      # the instrumentation, all other values will enable it.
       def enabled_by_env_var?
         var_name = name.dup.tap do |n|
           n.upcase!
           n.gsub!('::', '_')
+          n.gsub!('OPENTELEMETRY_', 'OTEL_RUBY_')
           n << '_ENABLED'
         end
         ENV[var_name] != 'false'

data/lib/opentelemetry/instrumentation/registry.rb

@@ -7,79 +7,79 @@
 module OpenTelemetry
   module Instrumentation
     # The instrumentation Registry contains information about instrumentation
-    # adapters available and facilitates discovery, installation and
+    # available and facilitates discovery, installation and
     # configuration. This functionality is primarily useful for SDK
     # implementors.
     class Registry
       def initialize
         @lock = Mutex.new
-        @adapters = []
+        @instrumentation = []
       end
 
       # @api private
-      def register(adapter)
+      def register(instrumentation)
         @lock.synchronize do
-          @adapters << adapter
+          @instrumentation << instrumentation
         end
       end
 
-      # Lookup an adapter definition by name. Returns nil if +adapter_name+
+      # Lookup an instrumentation definition by name. Returns nil if +instrumentation_name+
       # is not found.
       #
-      # @param [String] adapter_name A stringified class name for an adapter
-      # @return [Adapter]
-      def lookup(adapter_name)
+      # @param [String] instrumentation_name A stringified class name for an instrumentation
+      # @return [Instrumentation]
+      def lookup(instrumentation_name)
         @lock.synchronize do
-          find_adapter(adapter_name)
+          find_instrumentation(instrumentation_name)
         end
       end
 
-      # Install the specified adapters with optionally specified configuration.
+      # Install the specified instrumentation with optionally specified configuration.
       #
-      # @param [Array<String>] adapter_names An array of adapter names to
+      # @param [Array<String>] instrumentation_names An array of instrumentation names to
       #   install
-      # @param [optional Hash<String, Hash>] adapter_config_map A map of
-      #   adapter_name to config. This argument is optional and config can be
-      #   passed for as many or as few adapters as desired.
-      def install(adapter_names, adapter_config_map = {})
+      # @param [optional Hash<String, Hash>] instrumentation_config_map A map of
+      #   instrumentation_name to config. This argument is optional and config can be
+      #   passed for as many or as few instrumentations as desired.
+      def install(instrumentation_names, instrumentation_config_map = {})
         @lock.synchronize do
-          adapter_names.each do |adapter_name|
-            adapter = find_adapter(adapter_name)
-            OpenTelemetry.logger.warn "Could not install #{adapter_name} because it was not found" unless adapter
+          instrumentation_names.each do |instrumentation_name|
+            instrumentation = find_instrumentation(instrumentation_name)
+            OpenTelemetry.logger.warn "Could not install #{instrumentation_name} because it was not found" unless instrumentation
 
-            install_adapter(adapter, adapter_config_map[adapter.name])
+            install_instrumentation(instrumentation, instrumentation_config_map[instrumentation.name])
           end
         end
       end
 
       # Install all instrumentation available and installable in this process.
       #
-      # @param [optional Hash<String, Hash>] adapter_config_map A map of
-      #   adapter_name to config. This argument is optional and config can be
-      #   passed for as many or as few adapters as desired.
-      def install_all(adapter_config_map = {})
+      # @param [optional Hash<String, Hash>] instrumentation_config_map A map of
+      #   instrumentation_name to config. This argument is optional and config can be
+      #   passed for as many or as few instrumentations as desired.
+      def install_all(instrumentation_config_map = {})
         @lock.synchronize do
-          @adapters.map(&:instance).each do |adapter|
-            install_adapter(adapter, adapter_config_map[adapter.name])
+          @instrumentation.map(&:instance).each do |instrumentation|
+            install_instrumentation(instrumentation, instrumentation_config_map[instrumentation.name])
           end
         end
       end
 
       private
 
-      def find_adapter(adapter_name)
-        @adapters.detect { |a| a.instance.name == adapter_name }
+      def find_instrumentation(instrumentation_name)
+        @instrumentation.detect { |a| a.instance.name == instrumentation_name }
                    &.instance
       end
 
-      def install_adapter(adapter, config)
-        if adapter.install(config)
-          OpenTelemetry.logger.info "Adapter: #{adapter.name} was successfully installed"
+      def install_instrumentation(instrumentation, config)
+        if instrumentation.install(config)
+          OpenTelemetry.logger.info "Instrumentation: #{instrumentation.name} was successfully installed"
         else
-          OpenTelemetry.logger.warn "Adapter: #{adapter.name} failed to install"
+          OpenTelemetry.logger.warn "Instrumentation: #{instrumentation.name} failed to install"
         end
       rescue => e # rubocop:disable Style/RescueStandardError
-        OpenTelemetry.logger.warn "Adapter: #{adapter.name} unhandled exception" \
+        OpenTelemetry.logger.warn "Instrumentation: #{instrumentation.name} unhandled exception" \
                                   "during install #{e}: #{e.backtrace}"
       end
     end

data/lib/opentelemetry/trace.rb

@@ -9,32 +9,30 @@ module OpenTelemetry
   # single logical operation, consolidated across various components of an
   # application.
   module Trace
-    # An invalid trace identifier, a 16-byte array with all zero bytes, encoded
-    # as a hexadecimal string.
-    INVALID_TRACE_ID = ('0' * 32).freeze
+    # An invalid trace identifier, a 16-byte string with all zero bytes.
+    INVALID_TRACE_ID = ("\0" * 16).b
 
-    # An invalid span identifier, an 8-byte array with all zero bytes, encoded
-    # as a hexadecimal string.
-    INVALID_SPAN_ID = ('0' * 16).freeze
+    # An invalid span identifier, an 8-byte string with all zero bytes.
+    INVALID_SPAN_ID = ("\0" * 8).b
 
-    # Generates a valid trace identifier, a 16-byte array with at least one
-    # non-zero byte, encoded as a hexadecimal string.
+    # Generates a valid trace identifier, a 16-byte string with at least one
+    # non-zero byte.
     #
-    # @return [String] a hexadecimal string encoding of a valid trace ID.
+    # @return [String] a valid trace ID.
     def self.generate_trace_id
       loop do
-        id = Random::DEFAULT.bytes(16).unpack1('H*')
+        id = Random::DEFAULT.bytes(16)
         return id unless id == INVALID_TRACE_ID
       end
     end
 
-    # Generates a valid span identifier, an 8-byte array with at least one
-    # non-zero byte, encoded as a hexadecimal string.
+    # Generates a valid span identifier, an 8-byte string with at least one
+    # non-zero byte.
     #
-    # @return [String] a hexadecimal string encoding of a valid span ID.
+    # @return [String] a valid span ID.
     def self.generate_span_id
       loop do
-        id = Random::DEFAULT.bytes(8).unpack1('H*')
+        id = Random::DEFAULT.bytes(8)
         return id unless id == INVALID_SPAN_ID
       end
     end

data/lib/opentelemetry/trace/propagation/trace_context/trace_parent.rb

@@ -25,6 +25,10 @@ module OpenTelemetry
           REGEXP = /^(?<version>[A-Fa-f0-9]{2})-(?<trace_id>[A-Fa-f0-9]{32})-(?<span_id>[A-Fa-f0-9]{16})-(?<flags>[A-Fa-f0-9]{2})(?<ignored>-.*)?$/.freeze
           private_constant :REGEXP
 
+          INVALID_TRACE_ID = OpenTelemetry::Trace::INVALID_TRACE_ID.unpack1('H*')
+          INVALID_SPAN_ID = OpenTelemetry::Trace::INVALID_SPAN_ID.unpack1('H*')
+          private_constant :INVALID_TRACE_ID, :INVALID_SPAN_ID
+
           class << self
             # Creates a new {TraceParent} from a supplied {Trace::SpanContext}
             # @param [SpanContext] ctx The context
@@ -71,17 +75,17 @@ module OpenTelemetry
             end
 
             def parse_trace_id(string)
-              raise InvalidTraceIDError, string if string == OpenTelemetry::Trace::INVALID_TRACE_ID
+              raise InvalidTraceIDError, string if string == INVALID_TRACE_ID
 
               string.downcase!
-              string
+              Array(string).pack('H*')
             end
 
             def parse_span_id(string)
-              raise InvalidSpanIDError, string if string == OpenTelemetry::Trace::INVALID_SPAN_ID
+              raise InvalidSpanIDError, string if string == INVALID_SPAN_ID
 
               string.downcase!
-              string
+              Array(string).pack('H*')
             end
 
             def parse_flags(string)
@@ -102,7 +106,7 @@ module OpenTelemetry
           # converts this object into a string according to the w3c spec
           # @return [String] the serialized trace_parent
           def to_s
-            "00-#{trace_id}-#{span_id}-#{flag_string}"
+            "00-#{trace_id.unpack1('H*')}-#{span_id.unpack1('H*')}-#{flag_string}"
           end
 
           private

data/lib/opentelemetry/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-api
 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: benchmark-ipsa
@@ -168,7 +168,7 @@ files:
 - lib/opentelemetry/correlation_context/propagation/text_injector.rb
 - lib/opentelemetry/error.rb
 - lib/opentelemetry/instrumentation.rb
-- lib/opentelemetry/instrumentation/adapter.rb
+- lib/opentelemetry/instrumentation/base.rb
 - lib/opentelemetry/instrumentation/registry.rb
 - lib/opentelemetry/internal.rb
 - lib/opentelemetry/metrics.rb