opentelemetry-api 0.12.1 → 0.17.0

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

@@ -1,55 +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
-        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

@@ -1,73 +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 Callable] setter An optional callable that takes a
-        #   carrier, a key and a value and assigns the key-value pair in the
-        #   carrier. If omitted the default setter will be used which expects
-        #   the carrier to respond to [] and []=.
-        #
-        # @return [Object] carrier
-        def inject(carrier, context = Context.current, &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 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 []=.
-        #
-        # @return [Context] a new context updated with state extracted from the
-        #   carrier
-        def extract(carrier, context = Context.current, &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/default_getter.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
-      # The default getter module provides a common method for reading
-      # a key from a carrier that implements +[]+
-      module DefaultGetter
-        DEFAULT_GETTER = ->(carrier, key) { carrier[key] }
-        private_constant :DEFAULT_GETTER
-
-        # Returns a callable that can read a key from a carrier that implements
-        # +[]+. Useful for extract operations.
-        #
-        # @return [Callable]
-        def default_getter
-          DEFAULT_GETTER
-        end
-      end
-    end
-  end
-end

data/lib/opentelemetry/context/propagation/default_setter.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
-      # The default setter module provides a common method for writing
-      # a key into a carrier that implements +[]=+
-      module DefaultSetter
-        DEFAULT_SETTER = ->(carrier, key, value) { carrier[key] = value }
-        private_constant :DEFAULT_SETTER
-
-        # Returns a callable that can write a key into a carrier that implements
-        # +[]=+. Useful for inject operations.
-        #
-        # @return [Callable]
-        def default_setter
-          DEFAULT_SETTER
-        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)
-          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/context/propagation/propagation.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  class Context
-    module Propagation
-      # The Propagation class provides methods to inject and extract context
-      # to pass across process boundaries
-      class Propagation
-        # Get or set the global http propagator. Use a CompositePropagator
-        # to propagate multiple formats.
-        attr_accessor :http
-
-        # Get or set the global text propagator. Use a CompositePropagator
-        # to propagate multiple formats.
-        attr_accessor :text
-
-        def initialize
-          @http = @text = Propagator.new(NoopInjector.new, NoopExtractor.new)
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  class Context
-    module Propagation
-      # A propagator composes an extractor and injector into a single interface
-      # exposing inject and extract methods
-      class Propagator
-        # Returns a Propagator that delegates inject and extract to the provided
-        # injector and extractor
-        #
-        # @param [#inject] injector
-        # @param [#extract] extractor
-        def initialize(injector, extractor)
-          @injector = injector
-          @extractor = extractor
-        end
-
-        # Returns a carrier with the provided context injected according the
-        # underlying injector. Returns the carrier and logs a warning if
-        # injection fails.
-        #
-        # @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 Callable] setter An optional callable that takes a carrier, a key and
-        #   a value and assigns the key-value pair in the carrier. If omitted the default setter
-        #   will be used which expects the carrier to respond to [] and []=.
-        #
-        # @return [Object] carrier
-        def inject(carrier, context = Context.current, &setter)
-          @injector.inject(carrier, context, &setter)
-        rescue => e # rubocop:disable Style/RescueStandardError
-          OpenTelemetry.logger.warn "Error in Propagator#inject #{e.message}"
-          carrier
-        end
-
-        # Extracts and returns context from a carrier. Returns the provided
-        # context and logs a warning if an error if extraction fails.
-        #
-        # @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 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 []=.
-        #
-        # @return [Context] a new context updated with state extracted from the
-        #   carrier
-        def extract(carrier, context = Context.current, &getter)
-          @extractor.extract(carrier, context, &getter)
-        rescue => e # rubocop:disable Style/RescueStandardError
-          OpenTelemetry.logger.warn "Error in Propagator#extract #{e.message}"
-          context
-        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,245 +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
-      class << self
-        NAME_REGEX = /^(?:(?<namespace>[a-zA-Z0-9_:]+):{2})?(?<classname>[a-zA-Z0-9_]+)$/.freeze
-        private_constant :NAME_REGEX
-
-        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
-
-        def instance
-          @instance ||= new(instrumentation_name, instrumentation_version, install_blk,
-                            present_blk, compatible_blk)
-        end
-
-        private
-
-        attr_reader :install_blk, :present_blk, :compatible_blk
-
-        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)
-        @name = name
-        @version = version
-        @install_blk = install_blk
-        @present_blk = present_blk
-        @compatible_blk = compatible_blk
-        @config = {}
-        @installed = false
-      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 unless config.nil?
-        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
-
-      # 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