splunk-tracer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6f993c02bcf4f1f7390bf432557391ac09f411cb
+  data.tar.gz: 339e5a39c87a37e4595c00cdebbaa719fb21fc6c
+SHA512:
+  metadata.gz: 3d40f3c5d9c7147a4cf6895fd796dcf2d8ee81b2b3d3ee7c26ac5b0f832350cfeafb7c940629a953c45c83792ae8b112bf7b5e4c6d37e2969e244cc69df4a282
+  data.tar.gz: 941dfe9957dd358106159270a18b770920a5d11663d8619dd8e27dca63c5269478484ea072e94cbe8db885745c604669a9136e276ef901c3b0c123daf8c1ae8c

data/.circleci/config.yml

@@ -0,0 +1,31 @@
+version: 2
+
+jobs:
+  test:
+    docker:
+      - image: circleci/ruby:2
+    steps:
+      - checkout
+      - restore_cache:
+          keys:
+            - gem-cache-v2-{{ .Branch }}-{{ checksum "Gemfile.lock" }}
+            - gem-cache-v2-{{ .Branch }}-
+            - gem-cache-v2-
+      - run:
+          name: "set up environment"
+          command: |
+            echo 'export BUNDLE_PATH="$HOME/project/.bundler_cache"' >> $BASH_ENV
+            source $BASH_ENV
+      - run: bundle
+      - save_cache:
+          paths:
+            - ~/project/.bundler_cache
+          key: gem-cache-v2-{{ .Branch }}-{{ checksum "Gemfile.lock" }}
+      - run: make test
+
+workflows:
+  version: 2
+  test:
+    jobs:
+      - test
+

data/.gitignore

@@ -0,0 +1,12 @@
+.DS_Store
+.bundle/
+.yardoc
+_yardoc/
+coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*~
+splunk-tracer*.gem
+splunk*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,48 @@
+AllCops:
+  Exclude:
+    - spec/**/*
+    - .bundle/**/*
+    - bin/**/*
+    - vendor/**/*
+    - tmp/**/*
+    - log/**/*
+    - Rakefile
+    - splunktracing.gemspec
+
+Lint/AmbiguousOperator:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 147
+
+Metrics/BlockNesting:
+  Max: 4
+
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Max: 406
+
+Metrics/CyclomaticComplexity:
+  Max: 24
+
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes.
+# URISchemes: http, https
+Metrics/LineLength:
+  Enabled: false
+
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 88
+
+# Configuration parameters: CountComments.
+Metrics/ModuleLength:
+  Max: 1000
+
+Performance/RedundantBlockCall:
+  Enabled: false
+
+Style/PercentLiteralDelimiters:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in lightstep.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    splunk-tracer (0.1.0)
+      concurrent-ruby (~> 1.0)
+      opentracing (~> 0.4.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    bump (0.6.1)
+    concurrent-ruby (1.1.5)
+    diff-lcs (1.3)
+    docile (1.3.1)
+    json (2.1.0)
+    opentracing (0.4.3)
+    rack (2.0.5)
+    rake (11.3.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    timecop (0.8.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bump (~> 0.5)
+  rack (~> 2.0)
+  rake (~> 11.3)
+  rspec (~> 3.0)
+  simplecov (~> 0.16)
+  splunk-tracer!
+  timecop (~> 0.8.0)
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Splunk
+
+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.

data/Makefile

@@ -0,0 +1,24 @@
+.PHONY: build test benchmark publish
+
+build:
+	gem build splunktracing.gemspec
+
+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
+	ruby benchmark/threading/thread_test.rb
+
+bump-version:
+	ruby -e 'require "bump"; Bump::Bump.run("patch")'
+	make build	# rebuild after version increment
+	git tag `ruby scripts/version.rb`
+	git push
+	git push --tags
+
+publish: build test benchmark bump-version
+	gem push splunktracing-`ruby scripts/version.rb`.gem

data/README.md

@@ -0,0 +1,74 @@
+# splunk-tracer-ruby
+
+[![MIT license](http://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)
+
+The Splunk OpenTracing library for Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'splunk-tracer'
+
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install splunk-tracer
+
+
+## Getting started
+
+    require 'splunktracing'
+
+    # Initialize the singleton tracer
+    SplunkTracing.configure(component_name: 'splunktracing/ruby/example', access_token: 'your_access_token')
+
+    # Create a basic span and attach a log to the span
+    span = SplunkTracing.start_span('my_span')
+    span.log(event: 'hello world', count: 42)
+
+    # Create a child span (and add some artificial delays to illustrate the timing)
+    sleep(0.1)
+    child = SplunkTracing.start_span('my_child', child_of: span.span_context)
+    sleep(0.2)
+    child.finish
+    sleep(0.1)
+    span.finish
+
+## Thread Safety
+
+The Splunk Tracer is threadsafe. For increased performance, you can add the
+`concurrent-ruby-ext` gem to your Gemfile. This will enable C extensions for
+concurrent operations.
+
+The Splunk Tracer is also Fork-safe. When forking, the child process will
+not inherit the unflushed spans of the parent, so they will only be flushed
+once.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `make test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+
+
+
+This library is the Splunk binding for [OpenTracing](http://opentracing.io/). See the [OpenTracing Ruby API](https://github.com/opentracing/opentracing-ruby) for additional detail.
+
+## License
+
+The Splunk Tracer for Ruby is licensed under the MIT License. Details can be found in the LICENSE file.
+
+### Third-party libraries
+
+This is a fork of the Ruby tracer from Lightstep, which is also licensed under the MIT License. Links to the original repository and license are below:
+
+* [lightstep-tracer-ruby][lightstep]: [MIT][lightstep-license]
+
+[lightstep]:                      https://github.com/lightstep/lightstep-tracer-ruby
+[lightstep-license]:              https://github.com/lightstep/lightstep-tracer-ruby/blob/master/LICENSE

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/benchmark.rb

@@ -0,0 +1,138 @@
+require 'json'
+require 'splunktracing'
+require 'opentracing'
+require 'net/http'
+require 'pp'
+require 'uri'
+
+$base_url = "http://localhost:8000"
+
+$test_tracer = SplunkTracing::Tracer.new(
+  component_name: 'splunktracing/ruby/example',
+  transport: SplunkTracing::Transport::HTTPJSON.new(
+    host: 'localhost',
+    port: 8088,
+    encryption: SplunkTracing::Transport::HTTPJSON::ENCRYPTION_NONE,
+    access_token: 'none'
+  )
+)
+$noop_tracer = OpenTracing::Tracer.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/benchmark/bench.rb

@@ -0,0 +1,60 @@
+require 'benchmark'
+require 'securerandom'
+
+require 'bundler/setup'
+require 'splunktracing'
+
+rng = Random.new
+
+# Run a quick profile on logging lots of spans
+tracer = SplunkTracing::Tracer.new(
+  component_name: 'splunktracing/ruby/spec',
+  transport: SplunkTracing::Transport::Nil.new
+)
+
+Benchmark.bm(32) do |x|
+  x.report('Random.bytes.unpack') do
+    for i in 1..10_000; rng.bytes(8).unpack('H*')[0]; end
+  end
+  x.report('Random.bytes.each_byte.map') do
+    for i in 1..10_000; rng.bytes(8).each_byte.map { |b| b.to_s(16) }.join; end
+  end
+  x.report('SecureRandom.hex') do
+    for i in 1..10_000; SecureRandom.hex(8); end
+  end
+
+  x.report('start_span(100)') do
+    for i in 0..100; tracer.start_span('my_span').finish; end
+  end
+  x.report('start_span(1000)') do
+    for i in 0..1000; tracer.start_span('my_span').finish; end
+  end
+  x.report('start_span(10000)') do
+    for i in 0..10_000; tracer.start_span('my_span').finish; end
+  end
+
+  x.report('log_event(100)') do
+    span = tracer.start_span('my_span')
+    for i in 0..100; span.log(event: 'event', i: i); end
+    span.finish
+  end
+  x.report('log_event(1000)') do
+    span = tracer.start_span('my_span')
+    for i in 0..1000; span.log(event: 'event', i: i); end
+    span.finish
+  end
+  x.report('log_event(10000)') do
+    span = tracer.start_span('my_span')
+    for i in 0..10_000; span.log(event: 'event', i: i); end
+    span.finish
+  end
+
+  x.report('inject(10000)') do
+    span = tracer.start_span('my_span')
+    for i in 0..10_000
+      carrier = {}
+      tracer.inject(span.span_context, OpenTracing::FORMAT_TEXT_MAP, carrier)
+     end
+    span.finish
+  end
+end