class Zipkin::Tracer

Constants

DEFAULT_FLUSH_INTERVAL

Attributes

scope_manager[R]

@return [ScopeManager] the current ScopeManager, which may be a no-op but

may not be nil.

Public Class Methods

build(url:, service_name:, flush_interval: DEFAULT_FLUSH_INTERVAL, logger: Logger.new(STDOUT), sampler: Samplers::Const.new(true), encoder: Encoders::JsonEncoder) click to toggle source
# File lib/zipkin/tracer.rb, line 22
def self.build(url:,
               service_name:,
               flush_interval: DEFAULT_FLUSH_INTERVAL,
               logger: Logger.new(STDOUT),
               sampler: Samplers::Const.new(true),
               encoder: Encoders::JsonEncoder)
  encoder = encoder.new(Endpoint.local_endpoint(service_name))
  sender = HTTPClient.new(url: url, encoder: encoder, logger: logger)
  reporter = AsyncReporter.create(sender: sender, flush_interval: flush_interval)
  new(reporter, sender, logger: logger, sampler: sampler)
end
new(reporter, sender, logger: Logger.new(STDOUT), sampler:) click to toggle source
# File lib/zipkin/tracer.rb, line 34
def initialize(reporter, sender, logger: Logger.new(STDOUT), sampler:)
  @reporter = reporter
  @sender = sender
  @logger = logger
  @scope_manager = ScopeManager.new
  @sampler = sampler
end

Public Instance Methods

active_span() click to toggle source

@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.
# File lib/zipkin/tracer.rb, line 49
def active_span
  scope = scope_manager.active
  scope.span if scope
end
extract(format, carrier) click to toggle source

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

# File lib/zipkin/tracer.rb, line 178
def extract(format, carrier)
  case format
  when OpenTracing::FORMAT_TEXT_MAP
    trace_id = carrier['x-b3-traceid']
    parent_id = carrier['x-b3-parentspanid']
    span_id = carrier['x-b3-spanid']
    sampled = carrier['x-b3-sampled'] == '1'

    create_span_context(trace_id, span_id, parent_id, sampled)
  when OpenTracing::FORMAT_RACK
    trace_id = carrier['HTTP_X_B3_TRACEID']
    parent_id = carrier['HTTP_X_B3_PARENTSPANID']
    span_id = carrier['HTTP_X_B3_SPANID']
    sampled = carrier['HTTP_X_B3_SAMPLED'] == '1'

    create_span_context(trace_id, span_id, parent_id, sampled)
  else
    @logger.error "Logasm::Tracer with format #{format} is not supported yet"
    nil
  end
end
inject(span_context, format, carrier) click to toggle source

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`

# File lib/zipkin/tracer.rb, line 156
def inject(span_context, format, carrier)
  case format
  when OpenTracing::FORMAT_TEXT_MAP
    carrier['x-b3-traceid'] = span_context.trace_id
    carrier['x-b3-parentspanid'] = span_context.parent_id
    carrier['x-b3-spanid'] = span_context.span_id
    carrier['x-b3-sampled'] = span_context.sampled? ? '1' : '0'
  when OpenTracing::FORMAT_RACK
    carrier['X-B3-TraceId'] = span_context.trace_id
    carrier['X-B3-ParentSpanId'] = span_context.parent_id
    carrier['X-B3-SpanId'] = span_context.span_id
    carrier['X-B3-Sampled'] = span_context.sampled? ? '1' : '0'
  else
    @logger.error "Logasm::Tracer with format #{format} is not supported yet"
  end
end
start_active_span(operation_name, child_of: nil, references: nil, start_time: Time.now, tags: nil, ignore_active_scope: false, finish_on_close: true, **) { |scope| ... } click to toggle source

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

# File lib/zipkin/tracer.rb, line 122
def start_active_span(operation_name,
                      child_of: nil,
                      references: nil,
                      start_time: Time.now,
                      tags: nil,
                      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
start_span(operation_name, child_of: nil, start_time: Time.now, tags: nil, references: nil, ignore_active_scope: false, **) click to toggle source

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.<Paste>

@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

# File lib/zipkin/tracer.rb, line 74
def start_span(operation_name,
               child_of: nil,
               start_time: Time.now,
               tags: nil,
               references: nil,
               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 || {}
  )
end

Private Instance Methods

context_from_active_scope(ignore_active_scope) click to toggle source
# File lib/zipkin/tracer.rb, line 241
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
context_from_child_of(child_of) click to toggle source
# File lib/zipkin/tracer.rb, line 226
def context_from_child_of(child_of)
  return nil unless child_of
  child_of.respond_to?(:context) ? child_of.context : child_of
end
context_from_references(references) click to toggle source
# File lib/zipkin/tracer.rb, line 231
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
create_span_context(trace_id, span_id, parent_id, sampled) click to toggle source
# File lib/zipkin/tracer.rb, line 202
def create_span_context(trace_id, span_id, parent_id, sampled)
  return nil if !trace_id || !span_id

  SpanContext.new(
    trace_id: trace_id,
    parent_id: parent_id,
    span_id: span_id,
    sampled: sampled
  )
end
prepare_span_context(child_of:, references:, ignore_active_scope:) click to toggle source
# File lib/zipkin/tracer.rb, line 213
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