jaeger-client 0.7.1 → 1.1.0

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_parent_context(sampler = Samplers::Const.new(true))
-        trace_id = TraceId.generate
-        span_id = TraceId.generate
-        flags = sampler.sample?(trace_id) ? Flags::SAMPLED : Flags::NONE
-        new(trace_id: trace_id, span_id: span_id, flags: flags)
-      end
-
-      def self.create_from_parent_context(span_context)
-        trace_id = span_context.trace_id
-        parent_id = span_context.span_id
-        flags = span_context.flags
-        span_id = TraceId.generate
-        new(span_id: span_id, parent_id: parent_id, trace_id: trace_id, flags: flags)
-      end
-
-      attr_reader :span_id, :parent_id, :trace_id, :baggage, :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_parent_id
-        @to_parent_id ||= @parent_id.zero? ? nil : @parent_id.to_s(16)
-      end
-
-      def to_span_id
-        @to_span_id ||= @span_id.to_s(16)
-      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,189 +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 = prepare_span_context(
-          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.type' => @sampler.type,
-            :'sampler.param' => @sampler.param
-          )
-        )
-      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(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
-          SpanContext.create_parent_context(@sampler)
-        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

data/lib/jaeger/client/udp_sender.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './udp_sender/transport'
-require 'socket'
-require 'thread'
-
-module Jaeger
-  module Client
-    class UdpSender
-      def initialize(host:, port:, encoder:, logger:)
-        @encoder = encoder
-        @logger = logger
-
-        transport = Transport.new(host, port)
-        protocol = ::Thrift::CompactProtocol.new(transport)
-        @client = Jaeger::Thrift::Agent::Client.new(protocol)
-      end
-
-      def send_spans(spans)
-        batch = @encoder.encode(spans)
-        @client.emitBatch(batch)
-      rescue StandardError => error
-        @logger.error("Failure while sending a batch of spans: #{error}")
-      end
-    end
-  end
-end

data/lib/jaeger/client/udp_sender/transport.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Jaeger
-  module Client
-    class UdpSender
-      class Transport
-        FLAGS = 0
-
-        def initialize(host, port)
-          @socket = UDPSocket.new
-          @host = host
-          @port = port
-          @buffer = ::Thrift::MemoryBufferTransport.new
-        end
-
-        def write(str)
-          @buffer.write(str)
-        end
-
-        def flush
-          data = @buffer.read(@buffer.available)
-          send_bytes(data)
-        end
-
-        def open; end
-
-        def close; end
-
-        private
-
-        def send_bytes(bytes)
-          @socket.send(bytes, FLAGS, @host, @port)
-          @socket.flush
-        rescue Errno::ECONNREFUSED
-          warn 'Unable to connect to Jaeger Agent'
-        rescue StandardError => e
-          warn "Unable to send spans: #{e.message}"
-        end
-      end
-    end
-  end
-end