jaeger-client 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75c88fcea8c5fa02b502e8c2c6cb3838a246e714
-  data.tar.gz: 12d8f676f98d486d1b9db5e73c7dc757e46477a8
+  metadata.gz: 180ed5153f692c630fd0e0006b3d6265c5839875
+  data.tar.gz: 98dea74437333796b07bf81afba0558652b51623
 SHA512:
-  metadata.gz: 2eedd11ef42e96094a128fd32df3c3bf5a152d498dd09933a667930caa5af7f287c00bddf9524cc87429898ff78a7e3cc1d2da1b38f560be9f3731bfe0f42ac1
-  data.tar.gz: c478b9e68a708fd6a093d08b38c844136535a4b3723dd717392dd7ce5852ac01ba2a6b0948f954924cbe9a46daf6ea9e13f8d87242bb58a647fb44a0d0695d6f
+  metadata.gz: ef49bfeb6aee4d16534c256580efe859d6468f7f68c748db31166c10ba700416a8035d18c51d26d5b863dccae71c036f6e7a3645eb49c323d2a1ed80a9507f0f
+  data.tar.gz: 1965becd08d299d65067e503e64d926dfffe95b216b306334c562c3a9db703eba2bc4171e53586c4b180e262a3fda7bb9ceed38ec9b021ba475b680e5728ebe9

data/.rubocop.yml

@@ -16,6 +16,9 @@ RSpec/NestedGroups:
 RSpec/ExampleLength:
   Enabled: no
 
+RSpec/MultipleExpectations:
+  Enabled: no
+
 Metrics/BlockLength:
   Enabled: no
 
@@ -25,8 +28,20 @@ Metrics/MethodLength:
 Metrics/AbcSize:
   Enabled: no
 
+Metrics/ClassLength:
+  Enabled: no
+
+Metrics/ParameterLists:
+  Enabled: no
+
 Lint/UnusedMethodArgument:
   Enabled: no
 
+Style/FrozenStringLiteralComment:
+  Enabled: yes
+  EnforcedStyle: always
+  Include:
+    - 'lib/**/*'
+
 Metrics/LineLength:
   Max: 120

data/README.md

@@ -1,4 +1,7 @@
-# Jaeger::Client
+Jaeger::Client
+================
+[![Gem Version](https://badge.fury.io/rb/jaeger-client.svg)](https://rubygems.org/gems/jaeger-client)
+[![Build Status](https://travis-ci.org/salemove/jaeger-client-ruby.svg)](https://travis-ci.org/salemove/jaeger-client-ruby)
 
 OpenTracing Tracer implementation for Jaeger in Ruby
 
@@ -16,10 +19,27 @@ gem 'jaeger-client'
 require 'jaeger/client'
 OpenTracing.global_tracer = Jaeger::Client.build(host: 'localhost', port: 6831, service_name: 'echo')
 
-span = OpenTracing.start_span('span name')
-span.finish
+OpenTracing.start_active_span('span name') do
+  # do something
+
+  OpenTracing.start_active_span('inner span name') do
+    # do something else
+  end
+end
 ```
 
+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.
+
+#### 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)`
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/jaeger-client.gemspec

@@ -1,4 +1,3 @@
-
 lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 

data/lib/jaeger/client.rb

@@ -1,21 +1,31 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.push(File.dirname(__FILE__) + '/../../thrift/gen-rb')
 
 require 'opentracing'
+require 'jaeger/thrift/agent'
 
 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)
+    def self.build(host: '127.0.0.1',
+                   port: 6831,
+                   service_name:,
+                   flush_interval: DEFAULT_FLUSH_INTERVAL,
+                   sampler: Samplers::Const.new(true))
       collector = Collector.new
       sender = UdpSender.new(
         service_name: service_name,
@@ -25,7 +35,7 @@ module Jaeger
         flush_interval: flush_interval
       )
       sender.start
-      Tracer.new(collector, sender)
+      Tracer.new(collector, sender, sampler)
     end
   end
 end

data/lib/jaeger/client/carrier.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jaeger
   module Client
     # Carriers are used for inject and extract operations. A carrier should be a

data/lib/jaeger/client/collector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thread'
 
 module Jaeger
@@ -10,6 +12,7 @@ module Jaeger
       def send_span(span, end_time)
         context = span.context
         start_ts, duration = build_timestamps(span, end_time)
+        return if !context.sampled? && !context.debug?
 
         @buffer << Jaeger::Thrift::Span.new(
           'traceIdLow' => context.trace_id,
@@ -21,8 +24,8 @@ module Jaeger
           'flags' => context.flags,
           'startTime' => start_ts,
           'duration' => duration,
-          'tags' => build_tags(span.tags),
-          'logs' => build_logs(span.logs)
+          'tags' => span.tags,
+          'logs' => span.logs
         )
       end
 
@@ -32,27 +35,6 @@ module Jaeger
 
       private
 
-      def build_tags(tags)
-        tags.map { |name, value| build_tag(name, value) }
-      end
-
-      def build_logs(logs)
-        logs.map do |timestamp:, fields:|
-          Jaeger::Thrift::Log.new(
-            'timestamp' => (timestamp.to_f * 1_000_000).to_i,
-            'fields' => fields.map { |name, value| build_tag(name, value) }
-          )
-        end
-      end
-
-      def build_tag(name, value)
-        Jaeger::Thrift::Tag.new(
-          'key' => name.to_s,
-          'vType' => Jaeger::Thrift::TagType::STRING,
-          'vStr' => value.to_s
-        )
-      end
-
       def build_timestamps(span, end_time)
         start_ts = (span.start_time.to_f * 1_000_000).to_i
         end_ts = (end_time.to_f * 1_000_000).to_i

data/lib/jaeger/client/samplers.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'samplers/const'
+require_relative 'samplers/probabilistic'

data/lib/jaeger/client/samplers/const.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    module Samplers
+      # Const sampler
+      #
+      # A sampler that always makes the same decision for new traces depending
+      # on the initialization value. Use `Jaeger::Client::Samplers::Const.new(true)`
+      # to mark all new traces as sampled.
+      class Const
+        def initialize(decision)
+          @decision = decision
+          @param = decision ? '1' : '0'
+        end
+
+        def sample?(*)
+          @decision
+        end
+
+        def type
+          'const'
+        end
+
+        attr_reader :param
+      end
+    end
+  end
+end

data/lib/jaeger/client/samplers/probabilistic.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    module Samplers
+      # Probabilistic sampler
+      #
+      # Sample a portion of traces using trace_id as the random decision
+      class Probabilistic
+        def initialize(rate: 0.001)
+          @param = rate.to_s
+          if rate < 0.0 || rate > 1.0
+            raise "Sampling rate must be between 0.0 and 1.0, got #{rate.inspect}"
+          end
+          @boundary = TraceId::TRACE_ID_UPPER_BOUND * rate
+        end
+
+        def sample?(trace_id)
+          @boundary >= trace_id
+        end
+
+        def type
+          'probabilistic'
+        end
+
+        attr_reader :param
+      end
+    end
+  end
+end

data/lib/jaeger/client/scope.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jaeger
+  module Client
+    # Scope represents an OpenTracing Scope
+    #
+    # See http://www.opentracing.io for more information.
+    class Scope
+      def initialize(span, scope_stack, finish_on_close:)
+        @span = span
+        @scope_stack = scope_stack
+        @finish_on_close = finish_on_close
+        @closed = false
+      end
+
+      # Return the Span scoped by this Scope
+      #
+      # @return [Span]
+      attr_reader :span
+
+      # Close scope
+      #
+      # Mark the end of the active period for the current thread and Scope,
+      # updating the ScopeManager#active in the process.
+      def close
+        raise "Tried to close already closed span: #{inspect}" if @closed
+        @closed = true
+
+        @span.finish if @finish_on_close
+        removed_scope = @scope_stack.pop
+
+        if removed_scope != self # rubocop:disable Style/GuardClause
+          raise 'Removed non-active scope, ' \
+            "removed: #{removed_scope.inspect}, "\
+            "expected: #{inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/jaeger/client/scope_manager.rb

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

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

@@ -0,0 +1,35 @@
+# 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,3 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'span/thrift_tag_builder'
+require_relative 'span/thrift_log_builder'
+
 module Jaeger
   module Client
     class Span
@@ -17,7 +22,7 @@ module Jaeger
         @operation_name = operation_name
         @collector = collector
         @start_time = start_time
-        @tags = tags
+        @tags = tags.map { |key, value| ThriftTagBuilder.build(key, value) }
         @logs = []
       end
 
@@ -27,7 +32,8 @@ module Jaeger
       # @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)
-        @tags = @tags.merge(key => value)
+        # Using Thrift::Tag to avoid unnecessary memory allocations
+        @tags << ThriftTagBuilder.build(key, value)
       end
 
       # Set a baggage item on the span
@@ -47,12 +53,22 @@ module Jaeger
         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(timestamp: Time.now, **fields)
-        @logs << { timestamp: timestamp, fields: fields }
+      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}
@@ -61,14 +77,6 @@ module Jaeger
       def finish(end_time: Time.now)
         @collector.send_span(self, end_time)
       end
-
-      private
-
-      def build_binary_annotations
-        @tags.map do |name, value|
-          { key: name, value: value.to_s }
-        end
-      end
     end
   end
 end

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

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

@@ -0,0 +1,45 @@
+# 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,16 +1,19 @@
+# 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
+      def self.create_parent_context(sampler = Samplers::Const.new(true))
         trace_id = TraceId.generate
         span_id = TraceId.generate
-        flags = Flags::SAMPLED
+        flags = sampler.sample?(trace_id) ? Flags::SAMPLED : Flags::NONE
         new(trace_id: trace_id, span_id: span_id, flags: flags)
       end
 
@@ -32,6 +35,14 @@ module Jaeger
         @flags = flags
       end
 
+      def sampled?
+        @flags & Flags::SAMPLED == Flags::SAMPLED
+      end
+
+      def debug?
+        @flags & Flags::DEBUG == Flags::DEBUG
+      end
+
       def inspect
         to_s
       end

data/lib/jaeger/client/trace_id.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jaeger
   module Client
     module TraceId

data/lib/jaeger/client/tracer.rb

@@ -1,34 +1,124 @@
+# frozen_string_literal: true
+
 module Jaeger
   module Client
     class Tracer
-      def initialize(collector, sender)
+      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.
+      #   the newly-started Span. If a Span instance is provided, its
+      #   context is automatically substituted.
+      # @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, start_time: Time.now, tags: {}, **)
-        context =
-          if child_of
-            parent_context = child_of.respond_to?(:context) ? child_of.context : child_of
-            SpanContext.create_from_parent_context(parent_context)
-          else
-            SpanContext.create_parent_context
+      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,
+          ignore_active_scope: ignore_active_scope
+        )
+        Span.new(
+          context,
+          operation_name,
+          @collector,
+          start_time: start_time,
+          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
-        Span.new(context, operation_name, @collector, start_time: start_time, tags: tags)
+        end
+
+        scope
       end
 
       # Inject a SpanContext into the given carrier
@@ -91,6 +181,22 @@ module Jaeger
         mask = 2**(bits - 1)
         (num & ~mask) - (num & mask)
       end
+
+      def prepare_span_context(child_of:, ignore_active_scope:)
+        if child_of
+          parent_context = child_of.respond_to?(:context) ? child_of.context : child_of
+          return SpanContext.create_from_parent_context(parent_context)
+        end
+
+        unless ignore_active_scope
+          active_scope = @scope_manager.active
+          if active_scope
+            return SpanContext.create_from_parent_context(active_scope.span.context)
+          end
+        end
+
+        SpanContext.create_parent_context(@sampler)
+      end
     end
   end
 end

data/lib/jaeger/client/udp_sender.rb

@@ -1,5 +1,6 @@
+# frozen_string_literal: true
+
 require_relative './udp_sender/transport'
-require 'jaeger/thrift/agent'
 require 'socket'
 require 'thread'
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Jaeger
   module Client
     class UdpSender
@@ -6,7 +8,8 @@ module Jaeger
 
         def initialize(host, port)
           @socket = UDPSocket.new
-          @socket.connect(host, port)
+          @host = host
+          @port = port
           @buffer = ::Thrift::MemoryBufferTransport.new
         end
 
@@ -26,7 +29,7 @@ module Jaeger
         private
 
         def send_bytes(bytes)
-          @socket.send(bytes, FLAGS)
+          @socket.send(bytes, FLAGS, @host, @port)
           @socket.flush
         rescue Errno::ECONNREFUSED
           warn 'Unable to connect to Jaeger Agent'

data/lib/jaeger/client/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Jaeger
   module Client
-    VERSION = '0.4.2'.freeze
+    VERSION = '0.5.0'.freeze
   end
 end

data/script/create_trace

@@ -16,7 +16,7 @@ outer_span = tracer1.start_span(
   tags: { 'span.kind' => 'server' }
 )
 sleep 0.1
-outer_span.log(event: 'woop di doop', count: 5)
+outer_span.log_kv(event: 'woop di doop', count: 5)
 sleep 1
 
 inner_span = tracer1.start_span(
@@ -29,6 +29,7 @@ inner_span = tracer1.start_span(
     'peer.port' => 443
   }
 )
+inner_span.set_tag('error', false)
 sleep 0.3 # emulate network delay
 
 downstream_span = tracer2.start_span(

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jaeger-client
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - SaleMove TechMovers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-06 00:00:00.000000000 Z
+date: 2018-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -129,7 +129,16 @@ files:
 - lib/jaeger/client.rb
 - lib/jaeger/client/carrier.rb
 - lib/jaeger/client/collector.rb
+- lib/jaeger/client/samplers.rb
+- lib/jaeger/client/samplers/const.rb
+- lib/jaeger/client/samplers/probabilistic.rb
+- lib/jaeger/client/scope.rb
+- lib/jaeger/client/scope_manager.rb
+- lib/jaeger/client/scope_manager/scope_identifier.rb
+- lib/jaeger/client/scope_manager/scope_stack.rb
 - lib/jaeger/client/span.rb
+- lib/jaeger/client/span/thrift_log_builder.rb
+- lib/jaeger/client/span/thrift_tag_builder.rb
 - lib/jaeger/client/span_context.rb
 - lib/jaeger/client/trace_id.rb
 - lib/jaeger/client/tracer.rb