boost-jaeger-client 0.7.0

data/lib/jaeger/client/span.rb

@@ -0,0 +1,83 @@
+# 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, :references, :tags, :logs
+
+      # Creates a new {Span}
+      #
+      # @param context [SpanContext] the context of the span
+      # @param operation_name [String] the operation name
+      # @param collector [Collector] span collector
+      #
+      # @return [Span] a new Span
+      def initialize(context, operation_name, collector, start_time: Time.now, references: [], tags: {})
+        @context = context
+        @operation_name = operation_name
+        @collector = collector
+        @start_time = start_time
+        @references = references
+        @tags = tags.map { |key, value| ThriftTagBuilder.build(key, value) }
+        @logs = []
+      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)
+        # Using Thrift::Tag to avoid unnecessary memory allocations
+        @tags << ThriftTagBuilder.build(key, value)
+      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)
+        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)
+        nil
+      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)
+        @collector.send_span(self, end_time)
+      end
+    end
+  end
+end

data/lib/jaeger/client/span_context.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    # SpanContext holds the data for a span that gets inherited to child spans
+    class SpanContext
+      MAX_SIGNED_ID = (1 << 63) - 1
+      MAX_UNSIGNED_ID = (1 << 64)
+      ID_ATTRIBUTES = %i[span_id parent_id trace_id].freeze
+
+      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 :baggage, :flags, *ID_ATTRIBUTES
+
+      ID_ATTRIBUTES.each do |attribute|
+        define_method "thrift_#{attribute}" do
+          id_to_thrift_int(public_send(attribute))
+        end
+      end
+
+      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 inspect
+        to_s
+      end
+
+      def to_s
+        "#<SpanContext @span_id=#{span_id.to_s(16)} " \
+          "@parent_id=#{parent_id.to_s(16)} " \
+          "@trace_id=#{trace_id.to_s(16)} " \
+          "@flags=#{flags}>"
+      end
+
+      private
+
+      def id_to_thrift_int(id)
+        return unless id
+
+        puts id
+        id -= MAX_UNSIGNED_ID if id > MAX_SIGNED_ID
+        id
+      end
+    end
+  end
+end

data/lib/jaeger/client/trace_id.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    module TraceId
+      TRACE_ID_UPPER_BOUND = 2**64 - 1
+
+      def self.generate
+        rand(TRACE_ID_UPPER_BOUND)
+      end
+    end
+  end
+end

data/lib/jaeger/client/tracer.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    class Tracer
+      def initialize(collector, sender, sampler)
+        @collector = collector
+        @sender = sender
+        @sampler = sampler
+        @scope_manager = ScopeManager.new
+      end
+
+      def stop
+        @sender.stop
+      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,
+          @collector,
+          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)
+        case format
+        when OpenTracing::FORMAT_TEXT_MAP, OpenTracing::FORMAT_RACK
+          carrier['uber-trace-id'] = [
+            span_context.trace_id.to_s(16),
+            span_context.span_id.to_s(16),
+            span_context.parent_id.to_s(16),
+            span_context.flags.to_s(16)
+          ].join(':')
+        else
+          warn "Jaeger::Client with format #{format} is not supported yet"
+        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)
+        case format
+        when OpenTracing::FORMAT_TEXT_MAP
+          parse_context(carrier['uber-trace-id'])
+        when OpenTracing::FORMAT_RACK
+          parse_context(carrier['HTTP_UBER_TRACE_ID'])
+        else
+          warn "Jaeger::Client with format #{format} is not supported yet"
+          nil
+        end
+      end
+
+      private
+
+      def parse_context(trace)
+        return nil if !trace || trace == ''
+
+        trace_arguments = trace.split(':').map { |arg| arg.to_i(16) }
+        return nil if trace_arguments.size != 4
+
+        trace_id, span_id, parent_id, flags = trace_arguments
+        return nil if trace_id.zero? || span_id.zero?
+
+        SpanContext.new(
+          trace_id: trace_id,
+          parent_id: parent_id,
+          span_id: span_id,
+          flags: flags
+        )
+      end
+
+      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/transport.rb

@@ -0,0 +1,42 @@
+# 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

data/lib/jaeger/client/udp_sender.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative './udp_sender/transport'
+require 'socket'
+require 'thread'
+
+module Jaeger
+  module Client
+    class UdpSender
+      def initialize(service_name:, host:, port:, collector:, flush_interval:, logger:)
+        @service_name = service_name
+        @collector = collector
+        @flush_interval = flush_interval
+        @logger = logger
+
+        @tags = [
+          Jaeger::Thrift::Tag.new(
+            'key' => 'jaeger.version',
+            'vType' => Jaeger::Thrift::TagType::STRING,
+            'vStr' => 'Ruby-' + Jaeger::Client::VERSION
+          ),
+          Jaeger::Thrift::Tag.new(
+            'key' => 'hostname',
+            'vType' => Jaeger::Thrift::TagType::STRING,
+            'vStr' => Socket.gethostname
+          )
+        ]
+        ipv4 = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }
+        unless ipv4.nil?
+          @tags << Jaeger::Thrift::Tag.new(
+            'key' => 'ip',
+            'vType' => Jaeger::Thrift::TagType::STRING,
+            'vStr' => ipv4.ip_address
+          )
+        end
+
+        transport = Transport.new(host, port)
+        protocol = ::Thrift::CompactProtocol.new(transport)
+        @client = Jaeger::Thrift::Agent::Client.new(protocol)
+      end
+
+      def start
+        # Sending spans in a separate thread to avoid blocking the main thread.
+        @thread = Thread.new do
+          loop do
+            emit_batch(@collector.retrieve)
+            sleep @flush_interval
+          end
+        end
+      end
+
+      def stop
+        @thread.terminate if @thread
+        emit_batch(@collector.retrieve)
+      end
+
+      private
+
+      def emit_batch(thrift_spans)
+        return if thrift_spans.empty?
+
+        batch = Jaeger::Thrift::Batch.new(
+          'process' => Jaeger::Thrift::Process.new(
+            'serviceName' => @service_name,
+            'tags' => @tags
+          ),
+          'spans' => thrift_spans
+        )
+
+        @client.emitBatch(batch)
+      rescue StandardError => error
+        log_error(error, batch)
+      end
+
+      def log_error(error, failed_batch)
+        return unless @logger
+
+        @logger.error("[jaeger-client] Failure while sending batch: #{failed_batch.inspect} with error: #{error}")
+      end
+    end
+  end
+end

data/lib/jaeger/client/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    VERSION = '0.7.0'.freeze
+  end
+end

data/lib/jaeger/client.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push(File.dirname(__FILE__) + '/../../thrift/gen-rb')
+
+require 'opentracing'
+require 'jaeger/thrift/agent'
+require 'logger'
+
+require_relative 'client/tracer'
+require_relative 'client/span'
+require_relative 'client/span_context'
+require_relative 'client/scope'
+require_relative 'client/scope_manager'
+require_relative 'client/carrier'
+require_relative 'client/trace_id'
+require_relative 'client/udp_sender'
+require_relative 'client/collector'
+require_relative 'client/version'
+require_relative 'client/samplers'
+
+module Jaeger
+  module Client
+    DEFAULT_FLUSH_INTERVAL = 10
+
+    def self.build(host: '127.0.0.1',
+                   port: 6831,
+                   service_name:,
+                   flush_interval: DEFAULT_FLUSH_INTERVAL,
+                   sampler: Samplers::Const.new(true),
+                   logger: Logger.new(STDOUT))
+      collector = Collector.new
+      sender = UdpSender.new(
+        service_name: service_name,
+        host: host,
+        port: port,
+        collector: collector,
+        flush_interval: flush_interval,
+        logger: logger
+      )
+      sender.start
+      Tracer.new(collector, sender, sampler)
+    end
+  end
+end

data/script/create_follows_from_trace

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require 'bundler'
+Bundler.setup
+
+require 'jaeger/client'
+
+host = ENV['JAEGER_HOST'] || '127.0.0.1'
+port = ENV['JAEGER_HOST'] || 6831
+
+tracer1 = Jaeger::Client.build(host: host, port: port.to_i, service_name: 'test-service', flush_interval: 1)
+tracer2 = Jaeger::Client.build(host: host, port: port.to_i, service_name: 'downstream-service', flush_interval: 1)
+
+rpc_span = tracer1.start_span(
+  'receive request',
+  tags: { 'span.kind' => 'server' }
+)
+sleep 0.1
+rpc_span.log_kv(event: 'woop di doop', count: 5)
+sleep 1
+
+async_request_span = tracer1.start_span(
+  'request async action',
+  references: [
+    OpenTracing::Reference.child_of(rpc_span.context)
+  ],
+  tags: { 'span.kind' => 'producer' }
+)
+sleep 0.1
+
+async_request_span.finish
+rpc_span.finish
+
+sleep 0.5
+
+async_span = tracer2.start_span(
+  'async span started after rpc span',
+  references: [
+    OpenTracing::Reference.follows_from(async_request_span.context)
+  ],
+  tags: {
+    'span.kind' => 'consumer',
+    'peer.service' => 'downstream-service'
+  }
+)
+sleep 0.3 # emulate network delay
+async_span.finish
+
+tracer1.stop
+tracer2.stop
+
+puts 'Finished'

data/script/create_trace

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'bundler'
+Bundler.setup
+
+require 'jaeger/client'
+
+host = ENV['JAEGER_HOST'] || '127.0.0.1'
+port = ENV['JAEGER_HOST'] || 6831
+
+tracer1 = Jaeger::Client.build(host: host, port: port.to_i, service_name: 'test-service', flush_interval: 1)
+tracer2 = Jaeger::Client.build(host: host, port: port.to_i, service_name: 'downstream-service', flush_interval: 1)
+
+outer_span = tracer1.start_span(
+  'receive request',
+  tags: { 'span.kind' => 'server' }
+)
+sleep 0.1
+outer_span.log_kv(event: 'woop di doop', count: 5)
+sleep 1
+
+inner_span = tracer1.start_span(
+  'fetch info from downstream',
+  child_of: outer_span,
+  tags: {
+    'span.kind' => 'client',
+    'peer.service' => 'downstream-service',
+    'peer.ipv4' => '6.6.6.6',
+    'peer.port' => 443
+  }
+)
+inner_span.set_tag('error', false)
+sleep 0.3 # emulate network delay
+
+downstream_span = tracer2.start_span(
+  'downstream operation',
+  child_of: inner_span,
+  tags: { 'span.kind' => 'server' }
+)
+sleep 0.5
+downstream_span.finish
+
+sleep 0.2 # emulate network delay
+
+inner_span.finish
+
+sleep 0.1 # doing something with fetched info
+outer_span.finish
+
+tracer1.stop
+tracer2.stop
+
+puts 'Finished'