jaeger-client 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9af8a3a945af29ffe9f0045a2eff121fa519c689d04a680a41c7346a198cbf6
-  data.tar.gz: aad37d03df89f03707f91d3fd2f58b0af5b84122736b24f35edff791bb5f0b7a
+  metadata.gz: 7de16fd42664a20ad343e3fdc701f057b93df9e9c8ac6e76d4ea6b36895a7733
+  data.tar.gz: 32421b715a39b2710cae5bf9f7c6ca075872717ac53964de98429f063ebc93ba
 SHA512:
-  metadata.gz: 975e4605ee85e4e1b34b763233c16fe6ec3ec0ad88a01f8d1239b523e97bc8fde5844a2ca0d152c71a3b7f601be6237fd70303f31229cb995d896958180aaef7
-  data.tar.gz: 490214bc62f0a922e869b24ccbf5510538fa84365d50aafa1e892fe498aaa79e7bcb7d47da97445db8e07c4ebfb2481ecc6cb6aaeac7f81224e5a1ec90eb4616
+  metadata.gz: dacf1771b57e8f12074a0426b75b09b6a19610c13d4cb86b687e9930fc24a7e4a20f5c5e2819760e02a88baf01a8438f2175688be57dff2dffd80e5d45303522
+  data.tar.gz: b8bdaa192c6c2109b7711431ec9eebe3e4352e5e71426c65355abd5aad358cf0f4ceaaecb25dec2cf3a622d0982294ea578858234c71682a841f7bb3bb4090c0

data/README.md

@@ -43,11 +43,11 @@ To use `HttpSender`:
 ```ruby
 OpenTracing.global_tracer = Jaeger::Client.build(
   service_name: 'service_name',
-  reporter: Jaeger::Client::Reporter::RemoteReporter.new(
-    sender: Jaeger::Client::HttpSender.new(
+  reporter: Jaeger::Reporters::RemoteReporter.new(
+    sender: Jaeger::HttpSender.new(
       url: 'http://localhost:14268/api/traces',
       headers: { 'key' => 'value' }, # headers key is optional
-      encoder: Jaeger::Client::Encoders::ThriftEncoder.new(service_name: 'service_name')
+      encoder: Jaeger::Encoders::ThriftEncoder.new(service_name: 'service_name')
     ),
     flush_interval: 10
   )
@@ -61,7 +61,7 @@ NullReporter ignores all spans.
 ```ruby
 OpenTracing.global_tracer = Jaeger::Client.build(
   service_name: 'service_name',
-  reporter: Jaeger::Client::Reporter::NullReporter.new
+  reporter: Jaeger::Reporters::NullReporter.new
 )
 ```
 
@@ -72,43 +72,41 @@ LoggingReporter prints some details about the span using `logger`. This is meant
 ```ruby
 OpenTracing.global_tracer = Jaeger::Client.build(
   service_name: 'service_name',
-  reporter: Jaeger::Client::Reporter::LoggingReporter.new
+  reporter: Jaeger::Reporters::LoggingReporter.new
 )
 ```
 
 LoggingReporter can also use a custom logger. For this provide logger using `logger` keyword argument.
 
-See [opentracing-ruby](https://github.com/opentracing/opentracing-ruby) for more examples.
-
 ### Samplers
 
 #### Const sampler
 
-`Const` sampler always makes the same decision for new traces depending on the initialization value. Set `sampler` to: `Jaeger::Client::Samplers::Const.new(true)` to mark all new traces as sampled.
+`Const` sampler always makes the same decision for new traces depending on the initialization value. Set `sampler` to: `Jaeger::Samplers::Const.new(true)` to mark all new traces as sampled.
 
 #### Probabilistic sampler
 
-`Probabilistic` sampler samples traces with probability equal to `rate` (must be between 0.0 and 1.0). This can be enabled by setting `Jaeger::Client::Samplers::Probabilistic.new(rate: 0.1)`
+`Probabilistic` sampler samples traces with probability equal to `rate` (must be between 0.0 and 1.0). This can be enabled by setting `Jaeger::Samplers::Probabilistic.new(rate: 0.1)`
 
 #### RateLimiting sampler
 
 `RateLimiting` sampler samples at most `max_traces_per_second`. The distribution of sampled traces follows burstiness of the service, i.e. a service with uniformly distributed requests will have those requests sampled uniformly as well, but if requests are bursty, especially sub-second, then a number of sequential requests can be sampled each second.
 
-Set `sampler` to `Jaeger::Client::Samplers::RateLimiting.new(max_traces_per_second: 100)`
+Set `sampler` to `Jaeger::Samplers::RateLimiting.new(max_traces_per_second: 100)`
 
 #### GuaranteedThroughputProbabilistic sampler
 
 `GuaranteedThroughputProbabilistic` is a sampler that guarantees a throughput by using a Probabilistic sampler and RateLimiting sampler The RateLimiting sampler is used to establish a lower_bound so that every operation is sampled at least once in the time interval defined by the lower_bound.
 
-Set `sampler` to `Jaeger::Client::Samplers::GuaranteedThroughputProbabilistic.new(lower_bound: 10, rate: 0.001)`
+Set `sampler` to `Jaeger::Samplers::GuaranteedThroughputProbabilistic.new(lower_bound: 10, rate: 0.001)`
 
 #### PerOperation sampler
 
 `PerOperation` sampler leverages both Probabilistic sampler and RateLimiting sampler via the GuaranteedThroughputProbabilistic sampler. This sampler keeps track of all operations and delegates calls the the respective GuaranteedThroughputProbabilistic sampler.
 
 Set `sampler` to
-```
-  Jaeger::Client::Samplers::PerOperation.new(
+```ruby
+  Jaeger::Samplers::PerOperation.new(
     strategies: {
       per_operation_strategies: [
         { operation: 'GET /articles', probabilistic_sampling: 0.5 },
@@ -127,14 +125,14 @@ Jaeger Tracer supports Zipkin B3 Propagation HTTP headers, which are used by a l
 
 To set it up you need to change FORMAT_RACK injector and extractor.
 
-```
+```ruby
 OpenTracing.global_tracer = Jaeger::Client.build(
   service_name: 'service_name',
   injectors: {
-    OpenTracing::FORMAT_RACK => [Jaeger::Client::Injectors::B3RackCodec]
+    OpenTracing::FORMAT_RACK => [Jaeger::Injectors::B3RackCodec]
   },
   extractors: {
-    OpenTracing::FORMAT_RACK => [Jaeger::Client::Extractors::B3RackCodec]
+    OpenTracing::FORMAT_RACK => [Jaeger::Extractors::B3RackCodec]
   }
 )
 ```

data/crossdock/server

@@ -103,7 +103,7 @@ class HttpServer < Sinatra::Application
       host: 'jaeger-agent',
       port: 6831,
       flush_interval: 1,
-      sampler: Jaeger::Client::Samplers::Const.new(true)
+      sampler: Jaeger::Samplers::Const.new(true)
     )
   end
 

data/lib/jaeger/client.rb

@@ -6,25 +6,35 @@ 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/http_sender'
-require_relative 'client/reporters'
+require_relative 'tracer'
+require_relative 'span'
+require_relative 'span_context'
+require_relative 'scope'
+require_relative 'scope_manager'
+require_relative 'trace_id'
+require_relative 'udp_sender'
+require_relative 'http_sender'
+require_relative 'reporters'
 require_relative 'client/version'
-require_relative 'client/samplers'
-require_relative 'client/encoders/thrift_encoder'
-require_relative 'client/injectors'
-require_relative 'client/extractors'
-require_relative 'client/rate_limiter'
+require_relative 'samplers'
+require_relative 'encoders/thrift_encoder'
+require_relative 'injectors'
+require_relative 'extractors'
+require_relative 'rate_limiter'
 
 module Jaeger
   module Client
+    # We initially had everything under Jaeger::Client namespace. This however
+    # was not very useful and was removed. These assignments are here for
+    # backwards compatibility. Fine to remove in the next major version.
+    UdpSender = Jaeger::UdpSender
+    HttpSender = Jaeger::HttpSender
+    Encoders = Jaeger::Encoders
+    Samplers = Jaeger::Samplers
+    Reporters = Jaeger::Reporters
+    Injectors = Jaeger::Injectors
+    Extractors = Jaeger::Extractors
+
     DEFAULT_FLUSH_INTERVAL = 10
 
     def self.build(host: '127.0.0.1',

data/lib/jaeger/client/version.rb

@@ -2,6 +2,6 @@
 
 module Jaeger
   module Client
-    VERSION = '0.9.0'.freeze
+    VERSION = '0.10.0'.freeze
   end
 end

data/lib/jaeger/encoders/thrift_encoder.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Encoders
+    class ThriftEncoder
+      def initialize(service_name:)
+        @service_name = service_name
+        @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? # rubocop:disable Style/GuardClause
+          @tags << Jaeger::Thrift::Tag.new(
+            'key' => 'ip',
+            'vType' => Jaeger::Thrift::TagType::STRING,
+            'vStr' => ipv4.ip_address
+          )
+        end
+      end
+
+      def encode(spans)
+        Jaeger::Thrift::Batch.new(
+          'process' => Jaeger::Thrift::Process.new(
+            'serviceName' => @service_name,
+            'tags' => @tags
+          ),
+          'spans' => spans.map(&method(:encode_span))
+        )
+      end
+
+      private
+
+      def encode_span(span)
+        context = span.context
+        start_ts, duration = build_timestamps(span)
+
+        Jaeger::Thrift::Span.new(
+          'traceIdLow' => TraceId.uint64_id_to_int64(context.trace_id),
+          'traceIdHigh' => 0,
+          'spanId' => TraceId.uint64_id_to_int64(context.span_id),
+          'parentSpanId' => TraceId.uint64_id_to_int64(context.parent_id),
+          'operationName' => span.operation_name,
+          'references' => build_references(span.references || []),
+          'flags' => context.flags,
+          'startTime' => start_ts,
+          'duration' => duration,
+          'tags' => span.tags,
+          'logs' => span.logs
+        )
+      end
+
+      def build_references(references)
+        references.map do |ref|
+          Jaeger::Thrift::SpanRef.new(
+            'refType' => span_ref_type(ref.type),
+            'traceIdLow' => TraceId.uint64_id_to_int64(ref.context.trace_id),
+            'traceIdHigh' => 0,
+            'spanId' => TraceId.uint64_id_to_int64(ref.context.span_id)
+          )
+        end
+      end
+
+      def build_timestamps(span)
+        start_ts = (span.start_time.to_f * 1_000_000).to_i
+        end_ts = (span.end_time.to_f * 1_000_000).to_i
+        duration = end_ts - start_ts
+        [start_ts, duration]
+      end
+
+      def span_ref_type(type)
+        case type
+        when OpenTracing::Reference::CHILD_OF
+          Jaeger::Thrift::SpanRefType::CHILD_OF
+        when OpenTracing::Reference::FOLLOWS_FROM
+          Jaeger::Thrift::SpanRefType::FOLLOWS_FROM
+        else
+          warn "Jaeger::Client with format #{type} is not supported yet"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/extractors.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Extractors
+    class SerializedJaegerTrace
+      def self.parse(trace)
+        return nil if !trace || trace == ''
+
+        trace_arguments = trace.split(':').map(&TraceId.method(:base16_hex_id_to_uint64))
+        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
+    end
+
+    class JaegerTextMapCodec
+      def self.extract(carrier)
+        context = SerializedJaegerTrace.parse(carrier['uber-trace-id'])
+        return nil unless context
+
+        carrier.each do |key, value|
+          baggage_match = key.match(/\Auberctx-([\w-]+)\Z/)
+          if baggage_match
+            context.set_baggage_item(baggage_match[1], value)
+          end
+        end
+
+        context
+      end
+    end
+
+    class JaegerRackCodec
+      def self.extract(carrier)
+        serialized_trace = carrier['HTTP_UBER_TRACE_ID']
+        serialized_trace = CGI.unescape(serialized_trace) if serialized_trace
+        context = SerializedJaegerTrace.parse(serialized_trace)
+        return nil unless context
+
+        carrier.each do |key, value|
+          baggage_match = key.match(/\AHTTP_UBERCTX_(\w+)\Z/)
+          if baggage_match
+            key = baggage_match[1].downcase.tr('_', '-')
+            context.set_baggage_item(key, CGI.unescape(value))
+          end
+        end
+
+        context
+      end
+    end
+
+    class JaegerBinaryCodec
+      def self.extract(_carrier)
+        warn 'Jaeger::Client with binary format is not supported yet'
+      end
+    end
+
+    class B3RackCodec
+      def self.extract(carrier)
+        trace_id = TraceId.base16_hex_id_to_uint64(carrier['HTTP_X_B3_TRACEID'])
+        span_id = TraceId.base16_hex_id_to_uint64(carrier['HTTP_X_B3_SPANID'])
+        parent_id = TraceId.base16_hex_id_to_uint64(carrier['HTTP_X_B3_PARENTSPANID'])
+        flags = parse_flags(carrier['HTTP_X_B3_FLAGS'], carrier['HTTP_X_B3_SAMPLED'])
+
+        return nil if span_id.nil? || trace_id.nil?
+        return nil if span_id.zero? || trace_id.zero?
+
+        SpanContext.new(
+          trace_id: trace_id,
+          parent_id: parent_id,
+          span_id: span_id,
+          flags: flags
+        )
+      end
+
+      # if the flags header is '1' then the sampled header should not be present
+      def self.parse_flags(flags_header, sampled_header)
+        if flags_header == '1'
+          Jaeger::SpanContext::Flags::DEBUG
+        else
+          TraceId.base16_hex_id_to_uint64(sampled_header)
+        end
+      end
+      private_class_method :parse_flags
+    end
+
+    DEFAULT_EXTRACTORS = {
+      OpenTracing::FORMAT_TEXT_MAP => JaegerTextMapCodec,
+      OpenTracing::FORMAT_BINARY => JaegerBinaryCodec,
+      OpenTracing::FORMAT_RACK => JaegerRackCodec
+    }.freeze
+
+    def self.prepare(extractors)
+      DEFAULT_EXTRACTORS.reduce(extractors) do |acc, (format, default)|
+        provided_extractors = Array(extractors[format])
+        provided_extractors += [default] if provided_extractors.empty?
+
+        acc.merge(format => provided_extractors)
+      end
+    end
+  end
+end

data/lib/jaeger/http_sender.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Jaeger
+  class HttpSender
+    def initialize(url:, headers: {}, encoder:, logger: Logger.new(STDOUT))
+      @encoder = encoder
+      @logger = logger
+
+      @uri = URI(url)
+      @uri.query = 'format=jaeger.thrift'
+
+      @transport = ::Thrift::HTTPClientTransport.new(@uri.to_s)
+      @transport.add_headers(headers)
+
+      @serializer = ::Thrift::Serializer.new
+    end
+
+    def send_spans(spans)
+      batch = @encoder.encode(spans)
+      @transport.write(@serializer.serialize(batch))
+      @transport.flush
+    rescue StandardError => error
+      @logger.error("Failure while sending a batch of spans: #{error}")
+    end
+  end
+end

data/lib/jaeger/injectors.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Injectors
+    def self.context_as_jaeger_string(span_context)
+      [
+        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(':')
+    end
+
+    class JaegerTextMapCodec
+      def self.inject(span_context, carrier)
+        carrier['uber-trace-id'] = Injectors.context_as_jaeger_string(span_context)
+        span_context.baggage.each do |key, value|
+          carrier["uberctx-#{key}"] = value
+        end
+      end
+    end
+
+    class JaegerRackCodec
+      def self.inject(span_context, carrier)
+        carrier['uber-trace-id'] =
+          CGI.escape(Injectors.context_as_jaeger_string(span_context))
+        span_context.baggage.each do |key, value|
+          carrier["uberctx-#{key}"] = CGI.escape(value)
+        end
+      end
+    end
+
+    class JaegerBinaryCodec
+      def self.inject(_span_context, _carrier)
+        warn 'Jaeger::Client with binary format is not supported yet'
+      end
+    end
+
+    class B3RackCodec
+      def self.inject(span_context, carrier)
+        carrier['x-b3-traceid'] = TraceId.to_hex(span_context.trace_id)
+        carrier['x-b3-spanid'] = TraceId.to_hex(span_context.span_id)
+        carrier['x-b3-parentspanid'] = TraceId.to_hex(span_context.parent_id)
+
+        # flags (for debug) and sampled headers are mutually exclusive
+        if span_context.flags == Jaeger::SpanContext::Flags::DEBUG
+          carrier['x-b3-flags'] = '1'
+        else
+          carrier['x-b3-sampled'] = span_context.flags.to_s(16)
+        end
+      end
+    end
+
+    DEFAULT_INJECTORS = {
+      OpenTracing::FORMAT_TEXT_MAP => JaegerTextMapCodec,
+      OpenTracing::FORMAT_BINARY => JaegerBinaryCodec,
+      OpenTracing::FORMAT_RACK => JaegerRackCodec
+    }.freeze
+
+    def self.prepare(extractors)
+      DEFAULT_INJECTORS.reduce(extractors) do |acc, (format, default)|
+        provided_extractors = Array(extractors[format])
+        provided_extractors += [default] if provided_extractors.empty?
+
+        acc.merge(format => provided_extractors)
+      end
+    end
+  end
+end