opentelemetry-api 0.3.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c91a5540309be0f2dcc70066b25eab314bed537321a6d4b8360b72077cb9da22
-  data.tar.gz: 925121d6b30bf9cf3b1a17c30afbfdf5e328b0374b23a8daade2cf1d486e795f
+  metadata.gz: 9aa5a0850640df96314f3fd539394f878d899b47e1a95e725abc6c0afd6b5a68
+  data.tar.gz: c64e3676eb965f77f64a14dd5b515128644d79e8337df46c49ddf652496c8384
 SHA512:
-  metadata.gz: 93299563d90db1b05e873f431e151dc1d2e7e05f54d0b5311985be42d15a3f33f50e3e35fb24e0ef063a26a3cc06333bcb304ee418dd590ed124c08416735b80
-  data.tar.gz: e7edc0bde321596ec89fedc87c1209e35a6b306b22a87aa0e761a4a77cd3b4d9f0239a486f7444f280008c733e9a8378369cb0640fd60b58106bf256b9bd4e5c
+  metadata.gz: e72ba6591aa9c38b2036c1c27994f280d331fca28817d19fba52991f4477afde6f1bbca040eeb8d4049f084e63ca1e7666f1ff7eed86a1ce43fd79995b4d0fa4
+  data.tar.gz: 903010838dae911df19e9f06dc41080bce7640eb7caab03b6b4c9ca36a9a65105f9b58ef68f3bb5258e66d30015286cb8b9d18ca9ae600c9e31b124412ce2872

data/.yardopts

@@ -1,9 +1,9 @@
 --no-private
 --title=OpenTelemetry API
 --markup=markdown
---main=OVERVIEW.md
+--main=README.md
 ./lib/opentelemetry/**/*.rb
 ./lib/opentelemetry.rb
 -
-OVERVIEW.md
+README.md
 CHANGELOG.md

data/CHANGELOG.md

@@ -1 +1,20 @@
 # Release History: opentelemetry-api
+
+### v0.7.0 / 2020-10-07
+
+* FIXED: Safely navigate span variable during error cases 
+* DOCS: Standardize toplevel docs structure and readme 
+* DOCS: Fix param description in TextMapInjector for Baggage 
+
+### v0.6.0 / 2020-09-10
+
+* ADDED: Add support for OTEL_LOG_LEVEL env var
+* Documented array valued attributes [#343](https://github.com/open-telemetry/opentelemetry-ruby/pull/343)
+* Renamed CorrelationContext to Baggage [#338](https://github.com/open-telemetry/opentelemetry-ruby/pull/338)
+* Renamed Text* to TextMap* (propagators) [#335](https://github.com/open-telemetry/opentelemetry-ruby/pull/335)
+* Fixed exception semantic conventions (`span.record_error` -> `span.record_exception`) [#333](https://github.com/open-telemetry/opentelemetry-ruby/pull/333)
+* Removed support for lazy event creation [#329](https://github.com/open-telemetry/opentelemetry-ruby/pull/329)
+  * `name:` named parameter to `span.add_event` becomes first positional argument
+  * `Event` class removed from API
+* Added `hex_trace_id` and `hex_span_id` helpers to `SpanContext` [#332](https://github.com/open-telemetry/opentelemetry-ruby/pull/332)
+* Added `CorrelationContext::Manager.values` method to return correlations as a `Hash` [#323](https://github.com/open-telemetry/opentelemetry-ruby/pull/323)

data/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2020 OpenTelemetry Authors
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

data/lib/opentelemetry.rb

@@ -8,9 +8,8 @@ require 'logger'
 
 require 'opentelemetry/error'
 require 'opentelemetry/context'
-require 'opentelemetry/correlation_context'
-require 'opentelemetry/internal'
-require 'opentelemetry/instrumentation'
+require 'opentelemetry/baggage'
+require_relative './opentelemetry/instrumentation'
 require 'opentelemetry/metrics'
 require 'opentelemetry/trace'
 require 'opentelemetry/version'
@@ -23,9 +22,12 @@ require 'opentelemetry/version'
 module OpenTelemetry
   extend self
 
-  attr_writer :tracer_provider, :meter_provider, :correlations
+  attr_writer :tracer_provider, :meter_provider, :baggage, :logger
 
-  attr_accessor :logger
+  # @return [Object, Logger] configured Logger or a default STDOUT Logger.
+  def logger
+    @logger ||= Logger.new(STDOUT, level: ENV['OTEL_LOG_LEVEL'] || Logger::INFO)
+  end
 
   # @return [Object, Trace::TracerProvider] registered tracer provider or a
   #   default no-op implementation of the tracer provider.
@@ -45,17 +47,15 @@ module OpenTelemetry
     @instrumentation_registry ||= Instrumentation::Registry.new
   end
 
-  # @return [Object, CorrelationContext::Manager] registered
-  #   correlation context manager or a default no-op implementation of the
+  # @return [Object, Baggage::Manager] registered
+  #   baggage manager or a default no-op implementation of the
   #   manager.
-  def correlations
-    @correlations ||= CorrelationContext::Manager.new
+  def baggage
+    @baggage ||= Baggage::Manager.new
   end
 
   # @return [Context::Propagation::Propagation] an instance of the propagation API
   def propagation
     @propagation ||= Context::Propagation::Propagation.new
   end
-
-  self.logger = Logger.new(STDOUT)
 end

data/lib/opentelemetry/baggage.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'opentelemetry/baggage/builder'
+require 'opentelemetry/baggage/manager'
+require 'opentelemetry/baggage/propagation'
+
+module OpenTelemetry
+  # The Baggage module provides functionality to record and propagate
+  # baggage in a distributed trace
+  module Baggage
+  end
+end

data/lib/opentelemetry/{correlation_context → baggage}/builder.rb

@@ -5,8 +5,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 module OpenTelemetry
-  module CorrelationContext
-    # No op implementation of CorrelationContext::Builder
+  module Baggage
+    # No op implementation of Baggage::Builder
     class Builder
       def set_value(key, value); end
 

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

@@ -5,11 +5,12 @@
 # SPDX-License-Identifier: Apache-2.0
 
 module OpenTelemetry
-  module CorrelationContext
-    # No op implementation of CorrelationContext::Manager
+  module Baggage
+    # No op implementation of Baggage::Manager
     class Manager
       NOOP_BUILDER = Builder.new
-      private_constant :NOOP_BUILDER
+      EMPTY_VALUES = {}.freeze
+      private_constant(:NOOP_BUILDER, :EMPTY_VALUES)
 
       def build(context: Context.current)
         yield NOOP_BUILDER
@@ -24,6 +25,10 @@ module OpenTelemetry
         nil
       end
 
+      def values(context: Context.current)
+        EMPTY_VALUES
+      end
+
       def remove_value(key, context: Context.current)
         context
       end

data/lib/opentelemetry/baggage/propagation.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'opentelemetry/baggage/propagation/context_keys'
+require 'opentelemetry/baggage/propagation/text_map_injector'
+require 'opentelemetry/baggage/propagation/text_map_extractor'
+
+module OpenTelemetry
+  module Baggage
+    # The Baggage::Propagation module contains injectors and
+    # extractors for sending and receiving baggage over the wire
+    module Propagation
+      extend self
+
+      TEXT_MAP_EXTRACTOR = TextMapExtractor.new
+      TEXT_MAP_INJECTOR = TextMapInjector.new
+      RACK_EXTRACTOR = TextMapExtractor.new(
+        baggage_key: 'HTTP_BAGGAGE'
+      )
+      RACK_INJECTOR = TextMapInjector.new(
+        baggage_key: 'HTTP_BAGGAGE'
+      )
+
+      private_constant :TEXT_MAP_INJECTOR, :TEXT_MAP_EXTRACTOR, :RACK_INJECTOR,
+                       :RACK_EXTRACTOR
+
+      # Returns an extractor that extracts context using the W3C Baggage
+      # format
+      def text_map_injector
+        TEXT_MAP_INJECTOR
+      end
+
+      # Returns an injector that injects context using the W3C Baggage
+      # format
+      def text_map_extractor
+        TEXT_MAP_EXTRACTOR
+      end
+
+      # Returns an extractor that extracts context using the W3C Baggage
+      # format with Rack normalized keys (upcased and prefixed with
+      # HTTP_)
+      def rack_injector
+        RACK_INJECTOR
+      end
+
+      # Returns an injector that injects context using the W3C Baggage
+      # format with Rack normalized keys (upcased and prefixed with
+      # HTTP_)
+      def rack_extractor
+        RACK_EXTRACTOR
+      end
+    end
+  end
+end

data/lib/opentelemetry/baggage/propagation/context_keys.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Baggage
+    module Propagation
+      # The ContextKeys module contains the keys used to index baggage
+      # in a {Context} instance
+      module ContextKeys
+        extend self
+
+        BAGGAGE_KEY = Context.create_key('baggage')
+        private_constant :BAGGAGE_KEY
+
+        # Returns the context key that baggage are indexed by
+        #
+        # @return [Context::Key]
+        def baggage_key
+          BAGGAGE_KEY
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/{correlation_context/propagation/text_extractor.rb → baggage/propagation/text_map_extractor.rb}

@@ -7,41 +7,41 @@
 require 'cgi'
 
 module OpenTelemetry
-  module CorrelationContext
+  module Baggage
     module Propagation
-      # Extracts correlations from carriers in the W3C Correlation Context format
-      class TextExtractor
+      # Extracts baggage from carriers in the W3C Baggage format
+      class TextMapExtractor
         include Context::Propagation::DefaultGetter
 
-        # Returns a new TextExtractor that extracts context using the specified
+        # Returns a new TextMapExtractor that extracts context using the specified
         # header key
         #
-        # @param [String] correlation_context_key The correlation context header
+        # @param [String] baggage_key The baggage header
         #   key used in the carrier
-        # @return [TextExtractor]
-        def initialize(correlation_context_key: 'Correlation-Context')
-          @correlation_context_key = correlation_context_key
+        # @return [TextMapExtractor]
+        def initialize(baggage_key: 'baggage')
+          @baggage_key = baggage_key
         end
 
-        # Extract remote correlations from the supplied carrier.
+        # Extract remote baggage from the supplied carrier.
         # If extraction fails, the original context will be returned
         #
         # @param [Carrier] carrier The carrier to get the header from
-        # @param [Context] context The context to be updated with extracted correlations
+        # @param [Context] context The context to be updated with extracted baggage
         # @param [optional Callable] getter An optional callable that takes a carrier and a key and
         #   returns the value associated with the key. If omitted the default getter will be used
         #   which expects the carrier to respond to [] and []=.
         # @yield [Carrier, String] if an optional getter is provided, extract will yield the carrier
         #   and the header key to the getter.
-        # @return [Context] context updated with extracted correlations, or the original context
+        # @return [Context] context updated with extracted baggage, or the original context
         #   if extraction fails
         def extract(carrier, context, &getter)
           getter ||= default_getter
-          header = getter.call(carrier, @correlation_context_key)
+          header = getter.call(carrier, @baggage_key)
 
           entries = header.gsub(/\s/, '').split(',')
 
-          correlations = entries.each_with_object({}) do |entry, memo|
+          baggage = entries.each_with_object({}) do |entry, memo|
             # The ignored variable below holds properties as per the W3C spec.
             # OTel is not using them currently, but they might be used for
             # metadata in the future
@@ -50,7 +50,7 @@ module OpenTelemetry
             memo[k] = v
           end
 
-          context.set_value(ContextKeys.correlation_context_key, correlations)
+          context.set_value(ContextKeys.baggage_key, baggage)
         rescue StandardError
           context
         end

data/lib/opentelemetry/baggage/propagation/text_map_injector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Copyright 2019 OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'cgi'
+
+module OpenTelemetry
+  module Baggage
+    module Propagation
+      # Injects baggage using the W3C Baggage format
+      class TextMapInjector
+        include Context::Propagation::DefaultSetter
+
+        # Returns a new TextMapInjector that injects context using the specified
+        # header key
+        #
+        # @param [String] baggage_key The baggage header
+        #   key used in the carrier
+        # @return [TextMapInjector]
+        def initialize(baggage_key: 'baggage')
+          @baggage_key = baggage_key
+        end
+
+        # Inject in-process baggage into the supplied carrier.
+        #
+        # @param [Carrier] carrier The carrier to inject baggage into
+        # @param [Context] context The context to read baggage from
+        # @param [optional Callable] getter An optional callable that takes a carrier and a key and
+        #   returns the value associated with the key. If omitted the default getter will be used
+        #   which expects the carrier to respond to [] and []=.
+        # @yield [Carrier, String] if an optional getter is provided, inject will yield the carrier
+        #   and the header key to the getter.
+        # @return [Object] carrier with injected baggage
+        def inject(carrier, context, &setter)
+          return carrier unless (baggage = context[ContextKeys.baggage_key]) && !baggage.empty?
+
+          setter ||= default_setter
+          setter.call(carrier, @baggage_key, encode(baggage))
+
+          carrier
+        end
+
+        private
+
+        def encode(baggage)
+          baggage.inject(+'') do |memo, (k, v)|
+            memo << CGI.escape(k.to_s) << '=' << CGI.escape(v.to_s) << ','
+          end.chop!
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/context/propagation/composite_propagator.rb

@@ -38,12 +38,10 @@ module OpenTelemetry
         # @return [Object] carrier
         def inject(carrier, context = Context.current, &setter)
           @injectors.inject(carrier) do |memo, injector|
-            begin
-              injector.inject(memo, context, &setter)
-            rescue => e # rubocop:disable Style/RescueStandardError
-              OpenTelemetry.logger.warn "Error in CompositePropagator#inject #{e.message}"
-              carrier
-            end
+            injector.inject(memo, context, &setter)
+          rescue => e # rubocop:disable Style/RescueStandardError
+            OpenTelemetry.logger.warn "Error in CompositePropagator#inject #{e.message}"
+            carrier
           end
         end
 
@@ -63,12 +61,10 @@ module OpenTelemetry
         #   carrier
         def extract(carrier, context = Context.current, &getter)
           @extractors.inject(context) do |ctx, extractor|
-            begin
-              extractor.extract(carrier, ctx, &getter)
-            rescue => e # rubocop:disable Style/RescueStandardError
-              OpenTelemetry.logger.warn "Error in CompositePropagator#extract #{e.message}"
-              ctx
-            end
+            extractor.extract(carrier, ctx, &getter)
+          rescue => e # rubocop:disable Style/RescueStandardError
+            OpenTelemetry.logger.warn "Error in CompositePropagator#extract #{e.message}"
+            ctx
           end
         end
       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'