lightstep 0.9.9 → 0.9.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d77e4a3fbc58434184011abfd31e4c323af79615
-  data.tar.gz: 4cd3e0df3b6f019633e6c2f581a42122cdba81cb
+  metadata.gz: a02601ce2a4492bb33a7fd9efee072355800c67b
+  data.tar.gz: 9ac1d7f5f660d442382c7c76875a719502b4d94e
 SHA512:
-  metadata.gz: da86124b4d723ee69d538cae3139c4ddf3d3dbe08918122d52638e75000eb98e56b125383c555db2033d64cb9dd2daa39f2ec80b45dc43f00703294488cee1b7
-  data.tar.gz: 2bc31803d7967cf329764aace93653f851a53b88fd4801a3852f71dafdc5a114d71b3d1a1d28f250aa67aee24a96dc277a3e05e5895737e264afe84296e38423
+  metadata.gz: b0143c3a49f63d4b92a6d7df08eb719bc2702e69663b8a240954aa252869d88071d1f99da25764eba8c187d621b042e2c32f5ce187ae259c2db29f74be2f6833
+  data.tar.gz: 6ff5a25034f87dd93fe18c40df50bfb9b2036af6a00da19dcfd9b95177c575dfc05a352a350d7145e5c299a69b40fc257f5b38b7188064089d82083bd5014b5c

data/Makefile

@@ -7,6 +7,7 @@ test:
 	bundle exec rake spec
 	ruby example.rb
 	ruby examples/fork_children/main.rb
+	ruby examples/rack/inject_extract.rb
 
 benchmark:
 	ruby benchmark/bench.rb

data/benchmark.rb

@@ -0,0 +1,140 @@
+require 'json'
+require 'lightstep'
+require 'net/http'
+require 'pp'
+require 'uri'
+
+$base_url = "http://localhost:8000"
+
+$test_tracer = LightStep::Tracer.new(
+  component_name: 'lightstep/ruby/example',
+  transport: LightStep::Transport::HTTPJSON.new(
+    host: 'localhost',
+    port: 8000,
+    encryption: LightStep::Transport::HTTPJSON::ENCRYPTION_NONE,
+    access_token: 'none'
+  )
+)
+$noop_tracer = LightStep::Tracer.new(
+  component_name: 'ruby',
+  transport: LightStep::Transport::Nil.new
+)
+
+$prime_work = 982451653
+$logs_memory = ""
+$logs_size_max = (1 << 20)
+$nanos_per_second = 1e9
+
+def prepare_logs()
+  (0..$logs_size_max-1).each do |x|
+    $logs_memory << ("A".ord + x%26).chr
+  end
+end
+
+prepare_logs()
+
+def do_work(n)
+  x = $prime_work
+  while n != 0 do
+    x *= $prime_work
+    x %= 4294967296
+    n -= 1
+  end
+  return x
+end
+
+def test_body(tracer, control)
+  repeat    = control['Repeat']
+  sleepnano = control['Sleep']
+  sleepival = control['SleepInterval']
+  work      = control['Work']
+  logn      = control['NumLogs']
+  logsz     = control['BytesPerLog']
+  sleep_debt = 0  # Accumulated nanoseconds
+  sleeps    = 0
+  answer    = 0
+
+  (1..repeat).each do
+    span = tracer.start_span('span/test')
+    (1..logn).each do
+      span.log_event("testlog", $logs_memory[0..logsz])
+    end
+    answer += do_work(work)
+    span.finish()
+    sleep_debt += sleepnano
+    if sleep_debt <= sleepival
+      next
+    end
+    before = Time.now.to_f
+    sleep(sleep_debt / $nanos_per_second)
+    elapsed_secs = Time.now.to_f - before
+    elapsed = (elapsed_secs * $nanos_per_second).round
+    sleeps += elapsed_secs
+    sleep_debt -= elapsed
+  end
+  return sleeps, answer
+end
+
+def loop()
+  while true do
+    uri = URI.parse($base_url + '/control')
+    resp = Net::HTTP.get(uri)
+    control = JSON.parse(resp)
+
+    concurrent = control['Concurrent']
+    trace = control['Trace']
+
+    if control['Exit']
+      exit(0)
+    end
+
+    tracer = nil
+    if trace
+      tracer = $test_tracer
+    else
+      tracer = $noop_tracer
+    end
+
+    before = Time.now.to_f
+
+    # Note: Concurrency test not implemented
+    sleeps, answer = test_body(tracer, control)
+
+    after = Time.now.to_f
+    flush_dur = 0.0
+
+    if trace
+      tracer.flush()
+      flush_dur = Time.now.to_f - after
+    end
+
+    elapsed = after - before
+
+    path = sprintf('/result?timing=%f&flush=%f&s=%f&a=%s', elapsed, flush_dur, sleeps, answer)
+
+    uri = URI.parse($base_url + path)
+    resp = Net::HTTP.get(uri)
+  end
+end
+
+def backtrace_for_all_threads(signame)
+  File.open("/tmp/ruby_backtrace_#{Process.pid}.txt","a") do |f|
+      f.puts "--- got signal #{signame}, dump backtrace for all threads at #{Time.now}"
+      if Thread.current.respond_to?(:backtrace)
+        Thread.list.each do |t|
+          f.puts t.inspect
+          PP.pp(t.backtrace.delete_if {|frame| frame =~ /^#{File.expand_path(__FILE__)}/},
+               f) # remove frames resulting from calling this method
+        end
+      else
+          PP.pp(caller.delete_if {|frame| frame =~ /^#{File.expand_path(__FILE__)}/},
+               f) # remove frames resulting from calling this method
+      end
+  end
+end
+
+Signal.trap(29) do
+  backtrace_for_all_threads("INFO")
+end
+
+loop()

data/example.rb

@@ -31,4 +31,4 @@ end
 span.finish
 LightStep.flush
 puts 'Done!'
-puts "https://app.lightstep.com/#{access_token}/trace?span_guid=#{span.guid}&at_micros=#{span.start_micros}"
+puts "https://app.lightstep.com/#{access_token}/trace?span_guid=#{span.span_context.id}&at_micros=#{span.start_micros}"

data/examples/rack/inject_extract.rb

@@ -0,0 +1,66 @@
+require 'bundler/setup'
+require 'lightstep'
+
+require 'rack'
+require 'rack/server'
+
+$token = '{your_access_token}'
+$request_id = 'abc123'
+
+class Router
+  def initialize
+    @tracer = LightStep::Tracer.new(component_name: 'router', access_token: $token)
+  end
+
+  def call(env)
+    span = @tracer.start_span("router_call").set_baggage_item("request-id", $request_id)
+    span.log(event: "router_request", env: env)
+    puts "parent #{span.span_context.trace_id}"
+
+    client = Net::HTTP.new("localhost", "9002")
+    req = Net::HTTP::Post.new("/")
+    @tracer.inject(span, LightStep::Tracer::FORMAT_RACK, req)
+    res = client.request(req)
+
+    span.log(event: "application_response", response: res.to_s)
+    span.finish
+    @tracer.flush
+    puts "----> https://app.lightstep.com/#{$token}/trace?span_guid=#{span.span_context.id}&at_micros=#{span.start_micros} <----"
+    [200, {}, [res.body]]
+  end
+end
+
+class App
+  def initialize
+    @tracer = LightStep::Tracer.new(component_name: 'app', access_token: $token)
+  end
+
+  def call(env)
+    span = @tracer.extract("app_call", LightStep::Tracer::FORMAT_RACK, env)
+    puts "child  #{span.to_h[:trace_guid]}"
+    span.log(event: "application", env: env)
+    sleep 0.05
+    span.finish
+    @tracer.flush
+    [200, {}, ["application"]]
+  end
+end
+
+router_thread = Thread.new do
+  Thread.abort_on_exception = true
+  Rack::Server.start(app: Router.new, Port: 9001)
+end
+
+app_thread = Thread.new do
+  Thread.abort_on_exception = true
+  Rack::Server.start(app: App.new, Port: 9002)
+end
+
+loop do
+  begin
+    p Net::HTTP.get(URI("http://localhost:9001/"))
+    break
+  rescue Errno::ECONNREFUSED
+    sleep 0.05
+  end
+end

data/lib/lightstep/reporter.rb

@@ -1,3 +1,5 @@
+require 'lightstep/version'
+
 module LightStep
   # Reporter builds up reports of spans and flushes them to a transport
   class Reporter
@@ -5,7 +7,7 @@ module LightStep
     attr_accessor :max_span_records
     attr_accessor :period
 
-    def initialize(max_span_records:, transport:, guid:, component_name:)
+    def initialize(max_span_records:, transport:, guid:, component_name:, tags: {})
       @max_span_records = max_span_records
       @span_records = Concurrent::Array.new
       @dropped_spans = Concurrent::AtomicFixnum.new
@@ -24,7 +26,7 @@ module LightStep
           {Key: "lightstep.tracer_platform",         Value: "ruby"},
           {Key: "lightstep.tracer_version",          Value: LightStep::VERSION},
           {Key: "lightstep.tracer_platform_version", Value: RUBY_VERSION}
-        ]
+        ] + tags.map{|k,v| {Key: k.to_s, Value: v.to_s}}
       }.freeze
 
       reset_on_fork

data/lib/lightstep/span.rb

@@ -1,4 +1,5 @@
 require 'concurrent'
+require 'lightstep/span_context'
 
 module LightStep
   # Span represents an OpenTracer Span
@@ -10,7 +11,7 @@ module LightStep
 
     # Internal use only
     # @private
-    attr_reader :guid, :trace_guid, :start_micros, :end_micros, :baggage, :tags, :operation_name
+    attr_reader :start_micros, :end_micros, :baggage, :tags, :operation_name, :span_context
 
     # Creates a new {Span}
     #
@@ -23,38 +24,31 @@ module LightStep
     def initialize(
       tracer:,
       operation_name:,
-      child_of_guid: nil,
-      trace_guid:,
+      child_of_id: nil,
+      trace_id:,
       start_micros:,
       tags: nil,
       max_log_records:
     )
       @tags = Concurrent::Hash.new
       @tags.update(tags) unless tags.nil?
-      @baggage = Concurrent::Hash.new
       @log_records = Concurrent::Array.new
       @dropped_logs = Concurrent::AtomicFixnum.new
       @max_log_records = max_log_records
 
       @tracer = tracer
-      @guid = LightStep.guid
       self.operation_name = operation_name
       self.start_micros = start_micros
-      self.trace_guid = trace_guid
-      set_tag(:parent_span_guid, child_of_guid) if !child_of_guid.nil?
+      @span_context = SpanContext.new(id: LightStep.guid, trace_id: trace_id)
+      set_tag(:parent_span_guid, child_of_id) if !child_of_id.nil?
     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
+    # @param value [String] the value of the tag. If it's not a String
+    # it will be encoded with to_s
     def set_tag(key, value)
-      case value
-      when String, Fixnum, TrueClass, FalseClass
-        tags[key] = value
-      else
-        tags[key] = value.to_s
-      end
+      tags[key] = value.to_s
       self
     end
 
@@ -65,15 +59,29 @@ module LightStep
     # @param key [String] the key of the baggage item
     # @param value [String] the value of the baggage item
     def set_baggage_item(key, value)
-      baggage[key] = value
+      @span_context = SpanContext.new(
+        id: span_context.id,
+        trace_id: span_context.trace_id,
+        baggage: span_context.baggage.merge({key => value})
+      )
       self
     end
 
+    # Set all baggage at once. This will reset the baggage to the given param.
+    # @param baggage [Hash] new baggage for the span
+    def set_baggage(baggage = {})
+      @span_context = SpanContext.new(
+        id: span_context.id,
+        trace_id: span_context.trace_id,
+        baggage: baggage
+      )
+    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)
-      baggage[key]
+      span_context.baggage[key]
     end
 
     # Add a log entry to this span
@@ -117,8 +125,8 @@ module LightStep
     def to_h
       {
         runtime_guid: tracer.guid,
-        span_guid: guid,
-        trace_guid: trace_guid,
+        span_guid: span_context.id,
+        trace_guid: span_context.trace_id,
         span_name: operation_name,
         attributes: tags.map {|key, value|
           {Key: key.to_s, Value: value}
@@ -146,6 +154,6 @@ module LightStep
     private
 
     attr_reader :tracer, :dropped_logs, :log_records
-    attr_writer :guid, :trace_guid, :start_micros, :end_micros
+    attr_writer :start_micros, :end_micros
   end
 end

data/lib/lightstep/span_context.rb

@@ -0,0 +1,12 @@
+module LightStep
+  # SpanContext holds the data for a span that gets inherited to child spans
+  class SpanContext
+    attr_reader :id, :trace_id, :baggage
+
+    def initialize(id:, trace_id:, baggage: {})
+      @id = id.freeze
+      @trace_id = trace_id.freeze
+      @baggage = baggage.freeze
+    end
+  end
+end

data/lib/lightstep/tracer.rb

@@ -11,6 +11,7 @@ module LightStep
   class Tracer
     FORMAT_TEXT_MAP = 1
     FORMAT_BINARY = 2
+    FORMAT_RACK = 3
 
     class Error < LightStep::Error; end
     class ConfigurationError < LightStep::Tracer::Error; end
@@ -22,10 +23,11 @@ module LightStep
     # @param component_name [String] Component name to use for the tracer
     # @param access_token [String] The project access token when pushing to LightStep
     # @param transport [LightStep::Transport] How the data should be transported
+    # @param tags [Hash] Tracer-level tags
     # @return LightStep::Tracer
     # @raise LightStep::ConfigurationError if the group name or access token is not a valid string.
-    def initialize(component_name:, access_token: nil, transport: nil)
-      configure(component_name: component_name, access_token: access_token, transport: transport)
+    def initialize(component_name:, access_token: nil, transport: nil, tags: {})
+      configure(component_name: component_name, access_token: access_token, transport: transport, tags: tags)
     end
 
     def max_log_records
@@ -60,36 +62,44 @@ module LightStep
     # @param tags [Hash] tags for the span
     # @return [Span]
     def start_span(operation_name, child_of: nil, start_time: nil, tags: nil)
-      child_of_guid = nil
-      trace_guid = nil
+      child_of_id = nil
+      trace_id = nil
       if Span === child_of
-        child_of_guid = child_of.guid
-        trace_guid = child_of.trace_guid
+        child_of_id = child_of.span_context.id
+        trace_id = child_of.span_context.trace_id
       else
-        trace_guid = LightStep.guid
+        trace_id = LightStep.guid
       end
 
-      Span.new(
+      span = Span.new(
         tracer: self,
         operation_name: operation_name,
-        child_of_guid: child_of_guid,
-        trace_guid: trace_guid,
+        child_of_id: child_of_id,
+        trace_id: trace_id,
         start_micros: start_time.nil? ? LightStep.micros(Time.now) : LightStep.micros(start_time),
         tags: tags,
         max_log_records: max_log_records
       )
+
+      if Span === child_of
+        span.set_baggage(child_of.baggage)
+      end
+
+      span
     end
 
     # Inject a span into the given carrier
     # @param span [Span]
     # @param format [LightStep::Tracer::FORMAT_TEXT_MAP, LightStep::Tracer::FORMAT_BINARY]
-    # @param carrier [Hash-like]
+    # @param carrier [Hash]
     def inject(span, format, carrier)
       case format
       when LightStep::Tracer::FORMAT_TEXT_MAP
         inject_to_text_map(span, carrier)
       when LightStep::Tracer::FORMAT_BINARY
         warn 'Binary inject format not yet implemented'
+      when LightStep::Tracer::FORMAT_RACK
+        inject_to_rack(span, carrier)
       else
         warn 'Unknown inject format'
       end
@@ -98,7 +108,7 @@ module LightStep
     # Extract a span from a carrier
     # @param operation_name [String]
     # @param format [LightStep::Tracer::FORMAT_TEXT_MAP, LightStep::Tracer::FORMAT_BINARY]
-    # @param carrier [Hash-like]
+    # @param carrier [Hash]
     # @return [Span]
     def extract(operation_name, format, carrier)
       case format
@@ -107,6 +117,8 @@ module LightStep
       when LightStep::Tracer::FORMAT_BINARY
         warn 'Binary join format not yet implemented'
         nil
+      when LightStep::Tracer::FORMAT_RACK
+        extract_from_rack(operation_name, carrier)
       else
         warn 'Unknown join format'
         nil
@@ -147,7 +159,7 @@ module LightStep
 
     protected
 
-    def configure(component_name:, access_token: nil, transport: nil)
+    def configure(component_name:, access_token: nil, transport: nil, tags: {})
       raise ConfigurationError, "component_name must be a string" unless String === component_name
       raise ConfigurationError, "component_name cannot be blank"  if component_name.empty?
 
@@ -161,7 +173,8 @@ module LightStep
         max_span_records: max_span_records,
         transport: transport,
         guid: guid,
-        component_name: component_name
+        component_name: component_name,
+        tags: tags
       )
     end
 
@@ -176,11 +189,11 @@ module LightStep
     MIN_MAX_SPAN_RECORDS = 1
 
     def inject_to_text_map(span, carrier)
-      carrier[CARRIER_TRACER_STATE_PREFIX + 'spanid'] = span.guid
-      carrier[CARRIER_TRACER_STATE_PREFIX + 'traceid'] = span.trace_guid unless span.trace_guid.nil?
+      carrier[CARRIER_TRACER_STATE_PREFIX + 'spanid'] = span.span_context.id
+      carrier[CARRIER_TRACER_STATE_PREFIX + 'traceid'] = span.span_context.trace_id unless span.span_context.trace_id.nil?
       carrier[CARRIER_TRACER_STATE_PREFIX + 'sampled'] = 'true'
 
-      span.baggage.each do |key, value|
+      span.span_context.baggage.each do |key, value|
         carrier[CARRIER_BAGGAGE_PREFIX + key] = value
       end
     end
@@ -190,17 +203,46 @@ module LightStep
         tracer: self,
         operation_name: operation_name,
         start_micros: LightStep.micros(Time.now),
-        child_of_guid: carrier[CARRIER_TRACER_STATE_PREFIX + 'spanid'],
-        trace_guid: carrier[CARRIER_TRACER_STATE_PREFIX + 'traceid'],
+        child_of_id: carrier[CARRIER_TRACER_STATE_PREFIX + 'spanid'],
+        trace_id: carrier[CARRIER_TRACER_STATE_PREFIX + 'traceid'],
         max_log_records: max_log_records
       )
 
-      carrier.each do |key, value|
-        next unless key.start_with?(CARRIER_BAGGAGE_PREFIX)
-        plain_key = key.to_s[CARRIER_BAGGAGE_PREFIX.length..key.to_s.length]
-        span.set_baggage_item(plain_key, value)
+      baggage = carrier.reduce({}) do |baggage, tuple|
+        key, value = tuple
+        if key.start_with?(CARRIER_BAGGAGE_PREFIX)
+          plain_key = key.to_s[CARRIER_BAGGAGE_PREFIX.length..key.to_s.length]
+          baggage[plain_key] = value
+        end
+        baggage
       end
+      span.set_baggage(baggage)
+
       span
     end
+
+    def inject_to_rack(span, carrier)
+      carrier[CARRIER_TRACER_STATE_PREFIX + 'spanid'] = span.span_context.id
+      carrier[CARRIER_TRACER_STATE_PREFIX + 'traceid'] = span.span_context.trace_id unless span.span_context.trace_id.nil?
+      carrier[CARRIER_TRACER_STATE_PREFIX + 'sampled'] = 'true'
+
+      span.span_context.baggage.each do |key, value|
+        if key =~ /[^A-Za-z0-9\-_]/
+          # TODO: log the error internally
+          next
+        end
+        carrier[CARRIER_BAGGAGE_PREFIX + key] = value
+      end
+    end
+
+    def extract_from_rack(operation_name, env)
+      extract_from_text_map(operation_name, env.reduce({}){|memo, tuple|
+        raw_header, value = tuple
+        header = raw_header.gsub(/^HTTP_/, '').gsub("_", "-").downcase
+
+        memo[header] = value if header.start_with?(CARRIER_TRACER_STATE_PREFIX, CARRIER_BAGGAGE_PREFIX)
+        memo
+      })
+    end
   end
 end

data/lib/lightstep/version.rb

@@ -1,3 +1,3 @@
 module LightStep
-  VERSION = '0.9.9'.freeze
+  VERSION = '0.9.10'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lightstep
 version: !ruby/object:Gem::Version
-  version: 0.9.9
+  version: 0.9.10
 platform: ruby
 authors:
 - bcronin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-04 00:00:00.000000000 Z
+date: 2016-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -122,6 +122,7 @@ files:
 - Makefile
 - README.md
 - Rakefile
+- benchmark.rb
 - benchmark/bench.rb
 - benchmark/threading/thread_test.rb
 - bin/console
@@ -130,10 +131,12 @@ files:
 - example.rb
 - examples/fork_children/main.rb
 - examples/rack/hello.rb
+- examples/rack/inject_extract.rb
 - lib/lightstep.rb
 - lib/lightstep/global_tracer.rb
 - lib/lightstep/reporter.rb
 - lib/lightstep/span.rb
+- lib/lightstep/span_context.rb
 - lib/lightstep/tracer.rb
 - lib/lightstep/transport/base.rb
 - lib/lightstep/transport/callback.rb
@@ -162,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: LightStep OpenTracing Ruby bindings