jaeger-client 0.9.0 → 0.10.0

data/lib/jaeger/client/scope_manager.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'scope_manager/scope_stack'
-require_relative 'scope_manager/scope_identifier'
-
-module Jaeger
-  module Client
-    # ScopeManager represents an OpenTracing ScopeManager
-    #
-    # See http://www.opentracing.io for more information.
-    #
-    # The ScopeManager interface abstracts both the activation of Span instances
-    # via ScopeManager#activate and access to an active Span/Scope via
-    # ScopeManager#active
-    #
-    class ScopeManager
-      def initialize
-        @scope_stack = ScopeStack.new
-      end
-
-      # Make a span instance active
-      #
-      # @param span [Span] the Span that should become active
-      # @param finish_on_close [Boolean] whether the Span should automatically be
-      #   finished when Scope#close is called
-      # @return [Scope] instance to control the end of the active period for the
-      #  Span. It is a programming error to neglect to call Scope#close on the
-      #  returned instance.
-      def activate(span, finish_on_close: true)
-        return active if active && active.span == span
-        scope = Scope.new(span, @scope_stack, finish_on_close: finish_on_close)
-        @scope_stack.push(scope)
-        scope
-      end
-
-      # Return active scope
-      #
-      # If there is a non-null Scope, its wrapped Span becomes an implicit parent
-      # (as Reference#CHILD_OF) of any newly-created Span at
-      # Tracer#start_active_span or Tracer#start_span time.
-      #
-      # @return [Scope] the currently active Scope which can be used to access the
-      #   currently active Span.
-      def active
-        @scope_stack.peek
-      end
-    end
-  end
-end

data/lib/jaeger/client/scope_manager/scope_identifier.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    class ScopeManager
-      # @api private
-      class ScopeIdentifier
-        def self.generate
-          # 65..90.chr are characters between A and Z
-          "opentracing_#{(0...8).map { rand(65..90).chr }.join}".to_sym
-        end
-      end
-    end
-  end
-end

data/lib/jaeger/client/scope_manager/scope_stack.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    class ScopeManager
-      # @api private
-      class ScopeStack
-        def initialize
-          # Generate a random identifier to use as the Thread.current key. This is
-          # needed so that it would be possible to create multiple tracers in one
-          # thread (mostly useful for testing purposes)
-          @scope_identifier = ScopeIdentifier.generate
-        end
-
-        def push(scope)
-          store << scope
-        end
-
-        def pop
-          store.pop
-        end
-
-        def peek
-          store.last
-        end
-
-        private
-
-        def store
-          Thread.current[@scope_identifier] ||= []
-        end
-      end
-    end
-  end
-end

data/lib/jaeger/client/span.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'span/thrift_tag_builder'
-require_relative 'span/thrift_log_builder'
-
-module Jaeger
-  module Client
-    class Span
-      attr_accessor :operation_name
-
-      attr_reader :context, :start_time, :end_time, :references, :tags, :logs
-
-      # Creates a new {Span}
-      #
-      # @param context [SpanContext] the context of the span
-      # @param operation_name [String] the operation name
-      # @param reporter [#report] span reporter
-      #
-      # @return [Span] a new Span
-      def initialize(context, operation_name, reporter, start_time: Time.now, references: [], tags: {})
-        @context = context
-        @operation_name = operation_name
-        @reporter = reporter
-        @start_time = start_time
-        @references = references
-        @tags = []
-        @logs = []
-
-        tags.each { |key, value| set_tag(key, value) }
-      end
-
-      # Set a tag value on this span
-      #
-      # @param key [String] the key of the tag
-      # @param value [String, Numeric, Boolean] the value of the tag. If it's not
-      # a String, Numeric, or Boolean it will be encoded with to_s
-      def set_tag(key, value)
-        if key == 'sampling.priority'
-          if value.to_i > 0
-            return self if @context.debug?
-
-            @context.flags = @context.flags | SpanContext::Flags::SAMPLED | SpanContext::Flags::DEBUG
-          else
-            @context.flags = @context.flags & ~SpanContext::Flags::SAMPLED
-          end
-          return self
-        end
-
-        # Using Thrift::Tag to avoid unnecessary memory allocations
-        @tags << ThriftTagBuilder.build(key, value)
-
-        self
-      end
-
-      # Set a baggage item on the span
-      #
-      # @param key [String] the key of the baggage item
-      # @param value [String] the value of the baggage item
-      def set_baggage_item(key, value)
-        @context.set_baggage_item(key, value)
-        self
-      end
-
-      # Get a baggage item
-      #
-      # @param key [String] the key of the baggage item
-      #
-      # @return Value of the baggage item
-      def get_baggage_item(key)
-        @context.get_baggage_item(key)
-      end
-
-      # Add a log entry to this span
-      #
-      # @deprecated Use {#log_kv} instead.
-      def log(*args)
-        warn 'Span#log is deprecated. Please use Span#log_kv instead.'
-        log_kv(*args)
-      end
-
-      # Add a log entry to this span
-      #
-      # @param timestamp [Time] time of the log
-      # @param fields [Hash] Additional information to log
-      def log_kv(timestamp: Time.now, **fields)
-        # Using Thrift::Log to avoid unnecessary memory allocations
-        @logs << ThriftLogBuilder.build(timestamp, fields)
-        nil
-      end
-
-      # Finish the {Span}
-      #
-      # @param end_time [Time] custom end time, if not now
-      def finish(end_time: Time.now)
-        @end_time = end_time
-        @reporter.report(self)
-      end
-    end
-  end
-end

data/lib/jaeger/client/span/thrift_log_builder.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    class Span
-      class ThriftLogBuilder
-        FIELDS = Jaeger::Thrift::Log::FIELDS
-        TIMESTAMP = FIELDS[Jaeger::Thrift::Log::TIMESTAMP].fetch(:name)
-        LOG_FIELDS = FIELDS[Jaeger::Thrift::Log::LOG_FIELDS].fetch(:name)
-
-        def self.build(timestamp, fields)
-          Jaeger::Thrift::Log.new(
-            TIMESTAMP => (timestamp.to_f * 1_000_000).to_i,
-            LOG_FIELDS => fields.map { |key, value| ThriftTagBuilder.build(key, value) }
-          )
-        end
-      end
-    end
-  end
-end

data/lib/jaeger/client/span/thrift_tag_builder.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    class Span
-      class ThriftTagBuilder
-        FIELDS = Jaeger::Thrift::Tag::FIELDS
-        KEY = FIELDS[Jaeger::Thrift::Tag::KEY].fetch(:name)
-        VTYPE = FIELDS[Jaeger::Thrift::Tag::VTYPE].fetch(:name)
-        VLONG = FIELDS[Jaeger::Thrift::Tag::VLONG].fetch(:name)
-        VDOUBLE = FIELDS[Jaeger::Thrift::Tag::VDOUBLE].fetch(:name)
-        VBOOL = FIELDS[Jaeger::Thrift::Tag::VBOOL].fetch(:name)
-        VSTR = FIELDS[Jaeger::Thrift::Tag::VSTR].fetch(:name)
-
-        def self.build(key, value)
-          if value.is_a?(Integer)
-            Jaeger::Thrift::Tag.new(
-              KEY => key.to_s,
-              VTYPE => Jaeger::Thrift::TagType::LONG,
-              VLONG => value
-            )
-          elsif value.is_a?(Float)
-            Jaeger::Thrift::Tag.new(
-              KEY => key.to_s,
-              VTYPE => Jaeger::Thrift::TagType::DOUBLE,
-              VDOUBLE => value
-            )
-          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
-            Jaeger::Thrift::Tag.new(
-              KEY => key.to_s,
-              VTYPE => Jaeger::Thrift::TagType::BOOL,
-              VBOOL => value
-            )
-          else
-            Jaeger::Thrift::Tag.new(
-              KEY => key.to_s,
-              VTYPE => Jaeger::Thrift::TagType::STRING,
-              VSTR => value.to_s
-            )
-          end
-        end
-      end
-    end
-  end
-end

data/lib/jaeger/client/span_context.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    # SpanContext holds the data for a span that gets inherited to child spans
-    class SpanContext
-      module Flags
-        NONE = 0x00
-        SAMPLED = 0x01
-        DEBUG = 0x02
-      end
-
-      def self.create_from_parent_context(span_context)
-        new(
-          trace_id: span_context.trace_id,
-          parent_id: span_context.span_id,
-          span_id: TraceId.generate,
-          flags: span_context.flags,
-          baggage: span_context.baggage.dup
-        )
-      end
-
-      attr_reader :span_id, :parent_id, :trace_id, :baggage, :flags
-      attr_writer :flags
-
-      def initialize(span_id:, parent_id: 0, trace_id:, flags:, baggage: {})
-        @span_id = span_id
-        @parent_id = parent_id
-        @trace_id = trace_id
-        @baggage = baggage
-        @flags = flags
-      end
-
-      def sampled?
-        @flags & Flags::SAMPLED == Flags::SAMPLED
-      end
-
-      def debug?
-        @flags & Flags::DEBUG == Flags::DEBUG
-      end
-
-      def to_trace_id
-        @to_trace_id ||= @trace_id.to_s(16)
-      end
-
-      def to_span_id
-        @to_span_id ||= @span_id.to_s(16)
-      end
-
-      def set_baggage_item(key, value)
-        @baggage[key.to_s] = value.to_s
-      end
-
-      def get_baggage_item(key)
-        @baggage[key.to_s]
-      end
-    end
-  end
-end

data/lib/jaeger/client/trace_id.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    module TraceId
-      MAX_64BIT_SIGNED_INT = (1 << 63) - 1
-      MAX_64BIT_UNSIGNED_INT = (1 << 64) - 1
-      TRACE_ID_UPPER_BOUND = MAX_64BIT_UNSIGNED_INT + 1
-
-      def self.generate
-        rand(TRACE_ID_UPPER_BOUND)
-      end
-
-      def self.base16_hex_id_to_uint64(id)
-        return nil unless id
-        value = id.to_i(16)
-        value > MAX_64BIT_UNSIGNED_INT || value < 0 ? 0 : value
-      end
-
-      # Thrift defines ID fields as i64, which is signed, therefore we convert
-      # large IDs (> 2^63) to negative longs
-      def self.uint64_id_to_int64(id)
-        id > MAX_64BIT_SIGNED_INT ? id - MAX_64BIT_UNSIGNED_INT - 1 : id
-      end
-
-      # Convert an integer id into a 0 padded hex string.
-      # If the string is shorter than 16 characters, it will be padded to 16.
-      # If it is longer than 16 characters, it is padded to 32.
-      def self.to_hex(id)
-        hex_str = id.to_s(16)
-
-        # pad the string with '0's to 16 or 32 characters
-        if hex_str.length > 16
-          hex_str.rjust(32, '0')
-        else
-          hex_str.rjust(16, '0')
-        end
-      end
-    end
-  end
-end

data/lib/jaeger/client/tracer.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    class Tracer
-      def initialize(reporter:, sampler:, injectors:, extractors:)
-        @reporter = reporter
-        @sampler = sampler
-        @injectors = injectors
-        @extractors = extractors
-        @scope_manager = ScopeManager.new
-      end
-
-      # @return [ScopeManager] the current ScopeManager, which may be a no-op
-      #   but may not be nil.
-      attr_reader :scope_manager
-
-      # @return [Span, nil] the active span. This is a shorthand for
-      #   `scope_manager.active.span`, and nil will be returned if
-      #   Scope#active is nil.
-      def active_span
-        scope = scope_manager.active
-        scope.span if scope
-      end
-
-      # Starts a new span.
-      #
-      # This is similar to #start_active_span, but the returned Span will not
-      # be registered via the ScopeManager.
-      #
-      # @param operation_name [String] The operation name for the Span
-      # @param child_of [SpanContext, Span] SpanContext that acts as a parent to
-      #   the newly-started Span. If a Span instance is provided, its
-      #   context is automatically substituted. See [Reference] for more
-      #   information.
-      #
-      #   If specified, the `references` parameter must be omitted.
-      # @param references [Array<Reference>] An array of reference
-      #   objects that identify one or more parent SpanContexts.
-      # @param start_time [Time] When the Span started, if not now
-      # @param tags [Hash] Tags to assign to the Span at start time
-      # @param ignore_active_scope [Boolean] whether to create an implicit
-      #   References#CHILD_OF reference to the ScopeManager#active.
-      #
-      # @return [Span] The newly-started Span
-      def start_span(operation_name,
-                     child_of: nil,
-                     references: nil,
-                     start_time: Time.now,
-                     tags: {},
-                     ignore_active_scope: false,
-                     **)
-        context, sampler_tags = prepare_span_context(
-          operation_name: operation_name,
-          child_of: child_of,
-          references: references,
-          ignore_active_scope: ignore_active_scope
-        )
-        Span.new(
-          context,
-          operation_name,
-          @reporter,
-          start_time: start_time,
-          references: references,
-          tags: tags.merge(sampler_tags)
-        )
-      end
-
-      # Creates a newly started and activated Scope
-      #
-      # If the Tracer's ScopeManager#active is not nil, no explicit references
-      # are provided, and `ignore_active_scope` is false, then an inferred
-      # References#CHILD_OF reference is created to the ScopeManager#active's
-      # SpanContext when start_active is invoked.
-      #
-      # @param operation_name [String] The operation name for the Span
-      # @param child_of [SpanContext, Span] SpanContext that acts as a parent to
-      #   the newly-started Span. If a Span instance is provided, its
-      #   context is automatically substituted. See [Reference] for more
-      #   information.
-      #
-      #   If specified, the `references` parameter must be omitted.
-      # @param references [Array<Reference>] An array of reference
-      #   objects that identify one or more parent SpanContexts.
-      # @param start_time [Time] When the Span started, if not now
-      # @param tags [Hash] Tags to assign to the Span at start time
-      # @param ignore_active_scope [Boolean] whether to create an implicit
-      #   References#CHILD_OF reference to the ScopeManager#active.
-      # @param finish_on_close [Boolean] whether span should automatically be
-      #   finished when Scope#close is called
-      # @yield [Scope] If an optional block is passed to start_active it will
-      #   yield the newly-started Scope. If `finish_on_close` is true then the
-      #   Span will be finished automatically after the block is executed.
-      # @return [Scope] The newly-started and activated Scope
-      def start_active_span(operation_name,
-                            child_of: nil,
-                            references: nil,
-                            start_time: Time.now,
-                            tags: {},
-                            ignore_active_scope: false,
-                            finish_on_close: true,
-                            **)
-        span = start_span(
-          operation_name,
-          child_of: child_of,
-          references: references,
-          start_time: start_time,
-          tags: tags,
-          ignore_active_scope: ignore_active_scope
-        )
-        scope = @scope_manager.activate(span, finish_on_close: finish_on_close)
-
-        if block_given?
-          begin
-            yield scope
-          ensure
-            scope.close
-          end
-        end
-
-        scope
-      end
-
-      # Inject a SpanContext into the given carrier
-      #
-      # @param span_context [SpanContext]
-      # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
-      # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
-      def inject(span_context, format, carrier)
-        @injectors.fetch(format).each do |injector|
-          injector.inject(span_context, carrier)
-        end
-      end
-
-      # Extract a SpanContext in the given format from the given carrier.
-      #
-      # @param format [OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_BINARY, OpenTracing::FORMAT_RACK]
-      # @param carrier [Carrier] A carrier object of the type dictated by the specified `format`
-      # @return [SpanContext] the extracted SpanContext or nil if none could be found
-      def extract(format, carrier)
-        @extractors
-          .fetch(format)
-          .lazy
-          .map { |extractor| extractor.extract(carrier) }
-          .reject(&:nil?)
-          .first
-      end
-
-      private
-
-      def prepare_span_context(operation_name:, child_of:, references:, ignore_active_scope:)
-        context =
-          context_from_child_of(child_of) ||
-          context_from_references(references) ||
-          context_from_active_scope(ignore_active_scope)
-
-        if context
-          [SpanContext.create_from_parent_context(context), {}]
-        else
-          trace_id = TraceId.generate
-          is_sampled, tags = @sampler.sample?(
-            trace_id: trace_id,
-            operation_name: operation_name
-          )
-          span_context = SpanContext.new(
-            trace_id: trace_id,
-            span_id: trace_id,
-            flags: is_sampled ? SpanContext::Flags::SAMPLED : SpanContext::Flags::NONE
-          )
-          [span_context, tags]
-        end
-      end
-
-      def context_from_child_of(child_of)
-        return nil unless child_of
-        child_of.respond_to?(:context) ? child_of.context : child_of
-      end
-
-      def context_from_references(references)
-        return nil if !references || references.none?
-
-        # Prefer CHILD_OF reference if present
-        ref = references.detect do |reference|
-          reference.type == OpenTracing::Reference::CHILD_OF
-        end
-        (ref || references[0]).context
-      end
-
-      def context_from_active_scope(ignore_active_scope)
-        return if ignore_active_scope
-
-        active_scope = @scope_manager.active
-        active_scope.span.context if active_scope
-      end
-    end
-  end
-end