opentelemetry-api 0.14.0 → 1.0.0.rc2

data/lib/opentelemetry/baggage/manager.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-module OpenTelemetry
-  module Baggage
-    # No op implementation of Baggage::Manager
-    class Manager
-      NOOP_BUILDER = Builder.new
-      EMPTY_VALUES = {}.freeze
-      private_constant(:NOOP_BUILDER, :EMPTY_VALUES)
-
-      def build(context: Context.current)
-        yield NOOP_BUILDER
-        context
-      end
-
-      def set_value(key, value, context: Context.current)
-        context
-      end
-
-      def value(key, context: Context.current)
-        nil
-      end
-
-      def values(context: Context.current)
-        EMPTY_VALUES
-      end
-
-      def remove_value(key, context: Context.current)
-        context
-      end
-
-      def clear(context: Context.current)
-        context
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright The OpenTelemetry Authors
-#
-# SPDX-License-Identifier: Apache-2.0
-
-require 'cgi'
-
-module OpenTelemetry
-  module Baggage
-    module Propagation
-      # Extracts baggage from carriers in the W3C Baggage format
-      class TextMapExtractor
-        # Returns a new TextMapExtractor that extracts context using the specified
-        # getter
-        #
-        # @param [optional Getter] default_getter The default getter used to read
-        #   headers from a carrier during extract. Defaults to a
-        #   {OpenTelemetry::Context::Propagation::TextMapGetter} instance.
-        # @return [TextMapExtractor]
-        def initialize(default_getter = Context::Propagation.text_map_getter)
-          @default_getter = default_getter
-        end
-
-        # 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 baggage
-        # @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] context updated with extracted baggage, or the original context
-        #   if extraction fails
-        def extract(carrier, context, getter = nil)
-          getter ||= @default_getter
-          header = getter.get(carrier, BAGGAGE_KEY)
-
-          entries = header.gsub(/\s/, '').split(',')
-
-          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
-            kv, = entry.split(';', 2)
-            k, v = kv.split('=').map!(&CGI.method(:unescape))
-            memo[k] = v
-          end
-
-          context.set_value(ContextKeys.baggage_key, baggage)
-        rescue StandardError
-          context
-        end
-      end
-    end
-  end
-end

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,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