opentelemetry-api 0.16.0 → 1.0.0.rc3

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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The 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
-        # Returns a new TextMapInjector that injects context using the specified
-        # setter
-        #
-        # @param [optional Setter] default_setter The default setter used to
-        #   write context into a carrier during inject. Defaults to a
-        #   {OpenTelemetry::Context::Propagation::TextMapSetter} instance.
-        # @return [TextMapInjector]
-        def initialize(default_setter = Context::Propagation.text_map_setter)
-          @default_setter = default_setter
-        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 Setter] setter If the optional setter is provided, it
-        #   will be used to write context into the carrier, otherwise the default
-        #   setter will be used.
-        # @return [Object] carrier with injected baggage
-        def inject(carrier, context, setter = nil)
-          return carrier unless (baggage = context[ContextKeys.baggage_key]) && !baggage.empty?
-
-          setter ||= @default_setter
-          setter.set(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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  class Context
-    module Propagation
-      # A composite propagator composes a list of injectors and extractors into
-      # single interface exposing inject and extract methods. Injection and
-      # extraction will preserve the order of the injectors and extractors
-      # passed in during initialization.
-      class CompositePropagator
-        # Returns a Propagator that extracts using the provided extractors
-        # and injectors.
-        #
-        # @param [Array<#inject>] injectors
-        # @param [Array<#extract>] extractors
-        def initialize(injectors, extractors)
-          @injectors = injectors
-          @extractors = extractors
-        end
-
-        # Runs injectors in order and returns a carrier. If an injection fails
-        # a warning will be logged and remaining injectors will be executed.
-        # Always returns a valid carrier.
-        #
-        # @param [Object] carrier A carrier to inject context into
-        #   context into
-        # @param [optional Context] context Context to be injected into carrier.
-        #   Defaults to +Context.current+
-        # @param [optional Setter] setter If the optional setter is provided, it
-        #   will be used to write context into the carrier, otherwise the default
-        #   setter will be used.
-        #
-        # @return [Object] carrier
-        def inject(carrier, context: Context.current, setter: Context::Propagation.text_map_setter)
-          @injectors.inject(carrier) do |memo, injector|
-            injector.inject(memo, context, setter)
-          rescue => e # rubocop:disable Style/RescueStandardError
-            OpenTelemetry.logger.warn "Error in CompositePropagator#inject #{e.message}"
-            carrier
-          end
-        end
-
-        # Runs extractors in order and returns a Context updated with the
-        # results of each extraction. If an extraction fails, a warning will be
-        # logged and remaining extractors will continue to be executed. Always
-        # returns a valid context.
-        #
-        # @param [Object] carrier The carrier to extract context from
-        # @param [optional Context] context Context to be updated with the state
-        #   extracted from the carrier. Defaults to +Context.current+
-        # @param [optional Getter] getter If the optional getter is provided, it
-        #   will be used to read the header from the carrier, otherwise the default
-        #   getter will be used.
-        #
-        # @return [Context] a new context updated with state extracted from the
-        #   carrier
-        def extract(carrier, context: Context.current, getter: Context::Propagation.text_map_getter)
-          @extractors.inject(context) do |ctx, extractor|
-            extractor.extract(carrier, ctx, getter)
-          rescue => e # rubocop:disable Style/RescueStandardError
-            OpenTelemetry.logger.warn "Error in CompositePropagator#extract #{e.message}"
-            ctx
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  class Context
-    module Propagation
-      # A no-op extractor implementation
-      class NoopExtractor
-        # Extract a context from the given carrier
-        #
-        # @param [Object] carrier The carrier to extract the context from
-        # @param [Context] context The context to be upated with the extracted
-        #   context
-        # @param [optional Callable] getter An optional callable that takes a carrier and a key and
-        #   and returns the value associated with the key
-        # @return [Context]
-        def extract(carrier, context, getter = nil)
-          context
-        end
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  class Context
-    module Propagation
-      # A no-op injector implementation
-      class NoopInjector
-        # Inject the given context into the specified carrier
-        #
-        # @param [Object] carrier The carrier to inject the provided context
-        #   into
-        # @param [Context] context The context to be injected
-        # @param [optional Callable] setter An optional callable that takes a carrier and a key and
-        #   a value and assigns the key-value pair in the carrier
-        # @return [Object] carrier
-        def inject(carrier, context, &setter)
-          carrier
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/instrumentation.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-require 'opentelemetry/instrumentation/registry'
-require 'opentelemetry/instrumentation/base'
-
-module OpenTelemetry
-  # The instrumentation module contains functionality to register and install
-  # instrumentation
-  module Instrumentation
-  end
-end

data/lib/opentelemetry/instrumentation/base.rb

@@ -1,307 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module Instrumentation
-    # 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 Base will provide an install block, a present
-    # block, and possibly a compatible block. Below is an
-    # example:
-    #
-    # module OpenTelemetry
-    #   module Instrumentation
-    #     module Sinatra
-    #       class Instrumentation < OpenTelemetry::Instrumentation::Base
-    #         install do |config|
-    #           # install instrumentation, either by library hook or applying
-    #           # a monkey patch
-    #         end
-    #
-    #         # determine if the target library is present
-    #         present do
-    #           defined?(::Sinatra)
-    #         end
-    #
-    #         # if the target library is present, is it compatible?
-    #         compatible do
-    #           Gem.loaded_specs['sinatra'].version > MIN_VERSION
-    #         end
-    #       end
-    #     end
-    #   end
-    # end
-    #
-    # 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::Base are automatically
-    # registered with OpenTelemetry.instrumentation_registry which is used by
-    # SDKs for instrumentation discovery and installation.
-    #
-    # Instrumentation libraries can use the instrumentation subclass to easily gain
-    # a reference to its named tracer. For example:
-    #
-    # OpenTelemetry::Instrumentation::Sinatra.instance.tracer
-    #
-    # 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, OPENTELEMETRY shortened to OTEL_{LANG}, and '_ENABLED' appended.
-    # For example: OTEL_RUBY_INSTRUMENTATION_SINATRA_ENABLED = false.
-    class Base # rubocop:disable Metrics/ClassLength
-      class << self
-        NAME_REGEX = /^(?:(?<namespace>[a-zA-Z0-9_:]+):{2})?(?<classname>[a-zA-Z0-9_]+)$/.freeze
-        VALIDATORS = {
-          array: ->(v) { v.is_a?(Array) },
-          boolean: ->(v) { v == true || v == false }, # rubocop:disable Style/MultipleComparison
-          callable: ->(v) { v.respond_to?(:call) },
-          integer: ->(v) { v.is_a?(Integer) },
-          string: ->(v) { v.is_a?(String) }
-        }.freeze
-
-        private_constant :NAME_REGEX, :VALIDATORS
-
-        private :new # rubocop:disable Style/AccessModifierDeclarations
-
-        def inherited(subclass)
-          OpenTelemetry.instrumentation_registry.register(subclass)
-        end
-
-        # 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] instrumentation_name The full name of the instrumentation package
-        def instrumentation_name(instrumentation_name = nil)
-          if instrumentation_name
-            @instrumentation_name = instrumentation_name
-          else
-            @instrumentation_name ||= infer_name || 'unknown'
-          end
-        end
-
-        # 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] instrumentation_version The version of the instrumentation package
-        def instrumentation_version(instrumentation_version = nil)
-          if instrumentation_version
-            @instrumentation_version = instrumentation_version
-          else
-            @instrumentation_version ||= infer_version || '0.0.0'
-          end
-        end
-
-        # 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 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 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 instrumentation
-        def present(&blk)
-          @present_blk = blk
-        end
-
-        # 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 instrumentation
-        def compatible(&blk)
-          @compatible_blk = blk
-        end
-
-        # The option method is used to define default configuration options
-        # for the instrumentation library. It requires a name, default value,
-        # and a validation callable to be provided.
-        # @param [String] name The name of the configuration option
-        # @param default The default value to be used, or to used if validation fails
-        # @param [Callable, Symbol] validate Accepts a callable or a symbol that matches
-        # a key in the VALIDATORS hash.  The supported keys are, :array, :boolean,
-        # :callable, :integer, :string.
-        def option(name, default:, validate:)
-          validate = VALIDATORS[validate] || validate
-          raise ArgumentError, "validate must be #{VALIDATORS.keys.join(', ')}, or a callable" unless validate.respond_to?(:call)
-
-          @options ||= []
-          @options << { name: name, default: default, validate: validate }
-        end
-
-        def instance
-          @instance ||= new(instrumentation_name, instrumentation_version, install_blk,
-                            present_blk, compatible_blk, options)
-        end
-
-        private
-
-        attr_reader :install_blk, :present_blk, :compatible_blk, :options
-
-        def infer_name
-          @inferred_name ||= if (md = name.match(NAME_REGEX)) # rubocop:disable Naming/MemoizedInstanceVariableName
-                               md['namespace'] || md['classname']
-                             end
-        end
-
-        def infer_version
-          return unless (inferred_name = infer_name)
-
-          mod = inferred_name.split('::').map(&:to_sym).inject(Object) do |object, const|
-            object.const_get(const)
-          end
-          mod.const_get(:VERSION)
-        rescue NameError
-          nil
-        end
-      end
-
-      attr_reader :name, :version, :config, :installed, :tracer
-
-      alias installed? installed
-
-      def initialize(name, version, install_blk, present_blk,
-                     compatible_blk, options)
-        @name = name
-        @version = version
-        @install_blk = install_blk
-        @present_blk = present_blk
-        @compatible_blk = compatible_blk
-        @config = {}
-        @installed = false
-        @options = options
-      end
-
-      # 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 instrumentation
-      def install(config = {})
-        return true if installed?
-        return false unless installable?(config)
-
-        @config = config_options(config)
-        instance_exec(@config, &@install_blk)
-        @tracer ||= OpenTelemetry.tracer_provider.tracer(name, version)
-        @installed = true
-      end
-
-      # 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 instrumentation
-      def installable?(config = {})
-        @install_blk && enabled?(config) && present? && compatible?
-      end
-
-      # 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 Instrumentation subclasses, if no block is provided
-      # it's assumed to be compatible
-      def compatible?
-        return true unless @compatible_blk
-
-        instance_exec(&@compatible_blk)
-      end
-
-      # 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.
-      #
-      # @param [optional Hash] config The local config
-      def enabled?(config = nil)
-        return false unless enabled_by_env_var?
-        return config[:enabled] if config&.key?(:enabled)
-
-        true
-      end
-
-      private
-
-      # The config_options method is responsible for validating that the user supplied
-      # config hash is valid.
-      # Unknown configuration keys are not included in the final config hash.
-      # Invalid configuration values are logged, and replaced by the default.
-      #
-      # @param [Hash] user_config The user supplied configuration hash
-      def config_options(user_config) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        @options ||= {}
-        user_config ||= {}
-        validated_config = @options.each_with_object({}) do |option, h|
-          option_name = option[:name]
-          config_value = user_config[option_name]
-
-          value = if config_value.nil?
-                    option[:default]
-                  elsif option[:validate].call(config_value)
-                    config_value
-                  else
-                    OpenTelemetry.logger.warn(
-                      "Instrumentation #{name} configuration option #{option_name} value=#{config_value} " \
-                      "failed validation, falling back to default value=#{option[:default]}"
-                    )
-                    option[:default]
-                  end
-
-          h[option_name] = value
-        rescue StandardError => e
-          OpenTelemetry.handle_error(exception: e, message: "Instrumentation #{name} unexpected configuration error")
-          h[option_name] = option[:default]
-        end
-
-        dropped_config_keys = user_config.keys - validated_config.keys
-        OpenTelemetry.logger.warn("Instrumentation #{name} ignored the following unknown configuration options #{dropped_config_keys}") unless dropped_config_keys.empty?
-
-        validated_config
-      end
-
-      # 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'
-      end
-    end
-  end
-end