jaeger-client-with-ruby-32-support 2.0.0

data/lib/jaeger/tracer.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+module Jaeger
+  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
+    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.
+    #
+    # @yield [Span] If passed an optional block, start_span will yield the
+    #   newly-created span to the block. The span will be finished automatically
+    #   after the block is executed.
+    # @return [Span, Object] If passed an optional block, start_span will return
+    #  the block's return value, otherwise it returns the newly-started Span
+    #  instance, which has not been automatically registered via the
+    #  ScopeManager
+    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 = Span.new(
+        context,
+        operation_name,
+        @reporter,
+        start_time: start_time,
+        references: references,
+        tags: tags.merge(sampler_tags)
+      )
+
+      if block_given?
+        begin
+          yield(span)
+        ensure
+          span.finish
+        end
+      else
+        span
+      end
+    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_span 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, Object] If passed an optional block, start_active_span
+    #   returns the block's return value, otherwise it returns 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
+      else
+        scope
+      end
+    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
+    end
+  end
+end

data/lib/jaeger/udp_sender/transport.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Jaeger
+  class UdpSender
+    class Transport
+      FLAGS = 0
+
+      def initialize(host, port, logger:)
+        @socket = UDPSocket.new
+        @host = host
+        @port = port
+        @logger = logger
+        @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
+        @logger.warn 'Unable to connect to Jaeger Agent'
+      rescue StandardError => e
+        @logger.warn "Unable to send spans: #{e.message}"
+      end
+    end
+  end
+end

data/lib/jaeger/udp_sender.rb

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

data/script/create_follows_from_trace

@@ -0,0 +1,51 @@
+#!/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
+
+sleep 2
+
+puts 'Finished'

data/script/create_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)
+
+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
+
+sleep 2
+
+puts 'Finished'

data/thrift/agent.thrift

@@ -0,0 +1,32 @@
+# The MIT License (MIT)
+# 
+# Copyright (c) 2016 Uber Technologies, Inc.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+include "jaeger.thrift"
+include "zipkincore.thrift"
+
+namespace java com.uber.jaeger.agent.thrift
+namespace rb Jaeger.Thrift
+
+service Agent {
+    oneway void emitZipkinBatch(1: list<zipkincore.Span> spans)
+    oneway void emitBatch(1: jaeger.Batch batch)
+}

data/thrift/gen-rb/jaeger/thrift/agent/agent.rb

@@ -0,0 +1,118 @@
+#
+# Autogenerated by Thrift Compiler (0.10.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'jaeger/thrift/agent/agent_types'
+
+module Jaeger
+  module Thrift
+    module Agent
+      module Agent
+        class Client
+          include ::Thrift::Client
+
+          def emitZipkinBatch(spans)
+            send_emitZipkinBatch(spans)
+          end
+
+          def send_emitZipkinBatch(spans)
+            send_oneway_message('emitZipkinBatch', EmitZipkinBatch_args, :spans => spans)
+          end
+          def emitBatch(batch)
+            send_emitBatch(batch)
+          end
+
+          def send_emitBatch(batch)
+            send_oneway_message('emitBatch', EmitBatch_args, :batch => batch)
+          end
+        end
+
+        class Processor
+          include ::Thrift::Processor
+
+          def process_emitZipkinBatch(seqid, iprot, oprot)
+            args = read_args(iprot, EmitZipkinBatch_args)
+            @handler.emitZipkinBatch(args.spans)
+            return
+          end
+
+          def process_emitBatch(seqid, iprot, oprot)
+            args = read_args(iprot, EmitBatch_args)
+            @handler.emitBatch(args.batch)
+            return
+          end
+
+        end
+
+        # HELPER FUNCTIONS AND STRUCTURES
+
+        class EmitZipkinBatch_args
+          include ::Thrift::Struct, ::Thrift::Struct_Union
+          SPANS = 1
+
+          FIELDS = {
+            SPANS => {:type => ::Thrift::Types::LIST, :name => 'spans', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Jaeger::Thrift::Zipkin::Span}}
+          }
+
+          def struct_fields; FIELDS; end
+
+          def validate
+          end
+
+          ::Thrift::Struct.generate_accessors self
+        end
+
+        class EmitZipkinBatch_result
+          include ::Thrift::Struct, ::Thrift::Struct_Union
+
+          FIELDS = {
+
+          }
+
+          def struct_fields; FIELDS; end
+
+          def validate
+          end
+
+          ::Thrift::Struct.generate_accessors self
+        end
+
+        class EmitBatch_args
+          include ::Thrift::Struct, ::Thrift::Struct_Union
+          BATCH = 1
+
+          FIELDS = {
+            BATCH => {:type => ::Thrift::Types::STRUCT, :name => 'batch', :class => ::Jaeger::Thrift::Batch}
+          }
+
+          def struct_fields; FIELDS; end
+
+          def validate
+          end
+
+          ::Thrift::Struct.generate_accessors self
+        end
+
+        class EmitBatch_result
+          include ::Thrift::Struct, ::Thrift::Struct_Union
+
+          FIELDS = {
+
+          }
+
+          def struct_fields; FIELDS; end
+
+          def validate
+          end
+
+          ::Thrift::Struct.generate_accessors self
+        end
+
+      end
+
+    end
+  end
+end

data/thrift/gen-rb/jaeger/thrift/agent/agent_constants.rb

@@ -0,0 +1,15 @@
+#
+# Autogenerated by Thrift Compiler (0.10.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'jaeger/thrift/agent/agent_types'
+
+module Jaeger
+  module Thrift
+    module Agent
+    end
+  end
+end

data/thrift/gen-rb/jaeger/thrift/agent/agent_types.rb

@@ -0,0 +1,17 @@
+#
+# Autogenerated by Thrift Compiler (0.10.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'jaeger/thrift/jaeger_types'
+require 'jaeger/thrift/zipkin/zipkincore_types'
+
+
+module Jaeger
+  module Thrift
+    module Agent
+    end
+  end
+end

data/thrift/gen-rb/jaeger/thrift/agent.rb

@@ -0,0 +1,116 @@
+#
+# Autogenerated by Thrift Compiler (0.10.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'jaeger/thrift/agent_types'
+
+module Jaeger
+  module Thrift
+    module Agent
+      class Client
+        include ::Thrift::Client
+
+        def emitZipkinBatch(spans)
+          send_emitZipkinBatch(spans)
+        end
+
+        def send_emitZipkinBatch(spans)
+          send_oneway_message('emitZipkinBatch', EmitZipkinBatch_args, :spans => spans)
+        end
+        def emitBatch(batch)
+          send_emitBatch(batch)
+        end
+
+        def send_emitBatch(batch)
+          send_oneway_message('emitBatch', EmitBatch_args, :batch => batch)
+        end
+      end
+
+      class Processor
+        include ::Thrift::Processor
+
+        def process_emitZipkinBatch(seqid, iprot, oprot)
+          args = read_args(iprot, EmitZipkinBatch_args)
+          @handler.emitZipkinBatch(args.spans)
+          return
+        end
+
+        def process_emitBatch(seqid, iprot, oprot)
+          args = read_args(iprot, EmitBatch_args)
+          @handler.emitBatch(args.batch)
+          return
+        end
+
+      end
+
+      # HELPER FUNCTIONS AND STRUCTURES
+
+      class EmitZipkinBatch_args
+        include ::Thrift::Struct, ::Thrift::Struct_Union
+        SPANS = 1
+
+        FIELDS = {
+          SPANS => {:type => ::Thrift::Types::LIST, :name => 'spans', :element => {:type => ::Thrift::Types::STRUCT, :class => ::Jaeger::Thrift::Zipkin::Span}}
+        }
+
+        def struct_fields; FIELDS; end
+
+        def validate
+        end
+
+        ::Thrift::Struct.generate_accessors self
+      end
+
+      class EmitZipkinBatch_result
+        include ::Thrift::Struct, ::Thrift::Struct_Union
+
+        FIELDS = {
+
+        }
+
+        def struct_fields; FIELDS; end
+
+        def validate
+        end
+
+        ::Thrift::Struct.generate_accessors self
+      end
+
+      class EmitBatch_args
+        include ::Thrift::Struct, ::Thrift::Struct_Union
+        BATCH = 1
+
+        FIELDS = {
+          BATCH => {:type => ::Thrift::Types::STRUCT, :name => 'batch', :class => ::Jaeger::Thrift::Batch}
+        }
+
+        def struct_fields; FIELDS; end
+
+        def validate
+        end
+
+        ::Thrift::Struct.generate_accessors self
+      end
+
+      class EmitBatch_result
+        include ::Thrift::Struct, ::Thrift::Struct_Union
+
+        FIELDS = {
+
+        }
+
+        def struct_fields; FIELDS; end
+
+        def validate
+        end
+
+        ::Thrift::Struct.generate_accessors self
+      end
+
+    end
+
+  end
+end

data/thrift/gen-rb/jaeger/thrift/agent_constants.rb

@@ -0,0 +1,13 @@
+#
+# Autogenerated by Thrift Compiler (0.10.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'thrift'
+require 'jaeger/thrift/agent_types'
+
+module Jaeger
+  module Thrift
+  end
+end