splunk-tracer 0.1.0

data/benchmark/threading/thread_test.rb

@@ -0,0 +1,54 @@
+require 'bundler/setup'
+require 'splunktracing'
+
+SplunkTracing.configure(component_name: 'splunktracing/ruby/example', access_token: '{your_access_token}')
+
+puts 'Starting...'
+
+mutex = Mutex.new
+done = false
+span_count = 0
+percent_done = 0
+total_time = 0
+
+watchThread = Thread.new do
+  loop do
+    sleep(0.5)
+    mutex.lock
+    time_per_span = (1e6 * (total_time.to_f / span_count.to_f)).round(2)
+    puts "#{span_count} spans #{percent_done}% done #{total_time.round(2)} seconds (#{time_per_span} µs/span)"
+    is_done = done
+    mutex.unlock
+    Thread.exit if is_done
+  end
+end
+
+thread = Thread.new do
+  count = 0
+  total_time = 0
+  for j in 1..1000
+    start = Time.now
+    for i in 1..100
+      span = SplunkTracing.start_span('my_span')
+      span.log(event: 'hello world', count: i)
+      span.finish
+      count += 1
+    end
+    delta = Time.now - start
+
+    mutex.lock
+    percent_done = (100.0 * (count / 100_000.0)).ceil
+    span_count = count
+    total_time += delta
+    mutex.unlock
+  end
+end
+
+thread.join
+mutex.lock
+done = true
+mutex.unlock
+watchThread.join
+
+puts 'Done!'
+SplunkTracing.flush

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'splunktracing'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: 2.2.3

data/example.rb

@@ -0,0 +1,33 @@
+require 'bundler/setup'
+require 'simplecov'
+SimpleCov.command_name 'example.rb'
+SimpleCov.start
+require 'splunktracing'
+
+access_token = '08243c00-a31b-499d-9fae-776b41990997'
+
+SplunkTracing.configure(component_name: 'splunktracing/ruby/example', access_token: access_token)
+
+puts 'Starting operation...'
+span = SplunkTracing.start_span('my_span')
+thread1 = Thread.new do
+  (1..10).each do |i|
+    sleep(0.15)
+    puts "Logging event #{i}..."
+    span.log(event: 'hello world', count: i)
+  end
+end
+thread2 = Thread.new do
+  current = 1
+  (1..16).each do |i|
+    child = SplunkTracing.start_span('my_child', child_of: span.span_context)
+    sleep(0.1)
+    current *= 2
+    child.log(event: "2^#{i}", result: current)
+    child.finish
+  end
+end
+[thread1, thread2].each(&:join)
+span.finish
+SplunkTracing.flush
+puts 'Done!'

data/examples/fork_children/main.rb

@@ -0,0 +1,54 @@
+# A simple, manual test ensuring that tracer instances still report after a
+# Process.fork.
+
+require 'bundler/setup'
+require 'splunktracing'
+
+SplunkTracing.configure(
+  component_name: 'splunktracing/ruby/examples/fork_children',
+  access_token: '{your_access_token}'
+)
+
+puts 'Starting...'
+(1..20).each do |k|
+  puts "Explicit reset iteration #{k}..."
+
+  pid = Process.fork do
+    10.times do
+      span = SplunkTracing.start_span("my_forked_span-#{Process.pid}")
+      sleep(0.0025 * rand(k))
+      span.finish
+    end
+    SplunkTracing.flush
+  end
+
+  3.times do
+    span = SplunkTracing.start_span("my_process_span-#{Process.pid}")
+    sleep(0.0025 * rand(k))
+    span.set_tag(:empty, "")
+    span.set_tag(:full, "full")
+    span.finish
+  end
+
+  # Make sure redundant enable calls don't cause problems
+  # NOTE: disabling discards the buffer by default, so all spans
+  # get cleared here except the final toggle span
+  10.times do
+    SplunkTracing.disable
+    SplunkTracing.enable
+    SplunkTracing.disable
+    SplunkTracing.disable
+    SplunkTracing.enable
+    SplunkTracing.enable
+    span = SplunkTracing.start_span("my_toggle_span-#{Process.pid}")
+    sleep(0.0025 * rand(k))
+    span.finish
+  end
+
+  puts "Parent, pid #{Process.pid}, waiting on child pid #{pid}"
+  Process.wait(pid)
+end
+
+puts 'Done!'
+
+SplunkTracing.flush

data/examples/rack/hello.rb

@@ -0,0 +1,22 @@
+require 'bundler/setup'
+require 'splunktracing'
+
+require 'rack'
+require 'rack/server'
+
+SplunkTracing.configure(
+  component_name: 'splunktracing/ruby/examples/rack',
+  access_token: '{your_access_token}'
+)
+
+class HelloWorldApp
+  def self.call(env)
+    span = SplunkTracing.start_span('request',tags: {name: "G"})
+    span.log event: 'env', env: env
+    resp = [200, {}, ["Hello World. You said: #{env['QUERY_STRING']}"]]
+    span.finish
+    resp
+  end
+end
+
+Rack::Server.start app: HelloWorldApp

data/examples/rack/inject_extract.rb

@@ -0,0 +1,68 @@
+require 'bundler/setup'
+require 'splunktracing'
+require 'opentracing'
+
+require 'rack'
+require 'rack/server'
+
+$token = '{your_access_token}'
+$request_id = 'abc123'
+
+class Router
+  def initialize
+    @tracer = SplunkTracing::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.span_context, OpenTracing::FORMAT_RACK, req)
+    res = client.request(req)
+
+    span.log(event: "application_response", response: res.to_s)
+    span.finish
+    @tracer.flush
+    puts "----> #{$token} span_guid=#{span.span_context.id} at_micros=#{span.start_micros} <----"
+    [200, {}, [res.body]]
+  end
+end
+
+class App
+  def initialize
+    @tracer = SplunkTracing::Tracer.new(component_name: 'app', access_token: $token)
+  end
+
+  def call(env)
+    wire_ctx = @tracer.extract(OpenTracing::FORMAT_RACK, env)
+    span = @tracer.start_span("app_call", child_of: wire_ctx)
+    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://127.0.0.1:9001/"))
+    break
+  rescue Errno::ECONNREFUSED
+    sleep 0.05
+  end
+end

data/lib/splunktracing.rb

@@ -0,0 +1,50 @@
+require 'forwardable'
+require 'logger'
+
+# Splunk Tracer
+module SplunkTracing
+  extend SingleForwardable
+
+  # Base class for all SplunkTracing errors
+  class Error < StandardError; end
+
+  # Returns the singleton instance of the Tracer.
+  def self.instance
+    SplunkTracing::GlobalTracer.instance
+  end
+
+  def_delegator :instance, :configure
+  def_delegator :instance, :start_span
+  def_delegator :instance, :start_active_span
+  def_delegator :instance, :disable
+  def_delegator :instance, :enable
+  def_delegator :instance, :flush
+
+  # Convert a time to microseconds
+  def self.micros(time)
+    (time.to_f * 1E6).floor
+  end
+
+  # Returns a random guid. Note: this intentionally does not use SecureRandom,
+  # which is slower and cryptographically secure randomness is not required here.
+  def self.guid
+    unless @_lastpid == Process.pid
+      @_lastpid = Process.pid
+      @_rng = Random.new
+    end
+    @_rng.bytes(8).unpack('H*')[0]
+  end
+
+  def self.logger
+    @logger ||= defined?(::Rails) ? Rails.logger : Logger.new(STDOUT)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end
+
+require 'splunktracing/tracer'
+require 'splunktracing/global_tracer'
+require 'splunktracing/scope'
+require 'splunktracing/scope_manager'

data/lib/splunktracing/global_tracer.rb

@@ -0,0 +1,32 @@
+require 'singleton'
+
+module SplunkTracing
+  # GlobalTracer is a singleton version of the SplunkTracing::Tracer.
+  #
+  # You should access it via `SplunkTracing.instance`.
+  class GlobalTracer < Tracer
+    private
+    def initialize
+    end
+
+    public
+    include Singleton
+
+    # Configure the GlobalTracer
+    # See {SplunkTracing::Tracer#initialize}
+    def configure(**options)
+      if configured
+        SplunkTracing.logger.warn "[SplunkTracing] Already configured"
+        SplunkTracing.logger.info "Stack trace:\n\t#{caller.join("\n\t")}"
+        return
+      end
+
+      self.configured = true
+      super
+    end
+
+    private
+
+    attr_accessor :configured
+  end
+end

data/lib/splunktracing/reporter.rb

@@ -0,0 +1,119 @@
+require 'socket'
+
+require 'splunktracing/version'
+
+module SplunkTracing
+  # Reporter builds up reports of spans and flushes them to a transport
+  class Reporter
+    DEFAULT_PERIOD_SECONDS = 3.0
+    attr_accessor :max_span_records
+    attr_accessor :period
+
+    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
+      @transport = transport
+      @period = DEFAULT_PERIOD_SECONDS
+
+      start_time = SplunkTracing.micros(Time.now)
+      @report_start_time = start_time
+
+      @runtime = {
+        guid: guid,
+        device:  Socket.gethostname,
+        start_micros: start_time,
+        component_name: component_name,
+        tracer_platform: "ruby",
+        tracer_version: SplunkTracing::VERSION,
+        tracer_platform_version: RUBY_VERSION,
+        attrs: tags
+      }.freeze
+
+      reset_on_fork
+    end
+
+    def add_span(span)
+      reset_on_fork
+
+      @span_records.push(span.to_h)
+      if @span_records.size > max_span_records
+        @span_records.shift
+        @dropped_spans.increment
+      end
+    end
+
+    def clear
+      reset_on_fork
+
+      span_records = @span_records.slice!(0, @span_records.length)
+      @dropped_spans.increment(span_records.size)
+    end
+
+    def flush
+      reset_on_fork
+
+      return if @span_records.empty?
+
+      now = SplunkTracing.micros(Time.now)
+
+      span_records = @span_records.slice!(0, @span_records.length)
+      dropped_spans = 0
+      @dropped_spans.update do |old|
+        dropped_spans = old
+        0
+      end
+
+      report_request = {
+        runtime: @runtime,
+        oldest_micros: @report_start_time,
+        youngest_micros: now,
+        span_records: span_records,
+        internal_metrics: {
+          counts: [{
+            name: 'spans.dropped',
+            int64_value: dropped_spans
+          }]
+        }
+      }
+
+      @report_start_time = now
+
+      begin
+        @transport.report(report_request)
+      rescue StandardError => e
+        SplunkTracing.logger.error "SplunkTracing error reporting to collector: #{e.message}"
+        # an error occurs, add the previous dropped_spans and count of spans
+        # that would have been recorded
+        @dropped_spans.increment(dropped_spans + span_records.length)
+      end
+    end
+
+    private
+
+    # When the process forks, reset the child. All data that was copied will be handled
+    # by the parent. Also, restart the thread since forking killed it
+    def reset_on_fork
+      if @pid != $$
+        @pid = $$
+        @span_records.clear
+        @dropped_spans.value = 0
+        report_spans
+      end
+    end
+
+    def report_spans
+      return if @period <= 0
+      Thread.new do
+        begin
+          loop do
+            sleep(@period)
+            flush
+          end
+        rescue StandardError => e
+          SplunkTracing.logger.error "SplunkTracing failed to report spans: #{e.message}"
+        end
+      end
+    end
+  end
+end