instana 1.10.1-java

data/Troubleshooting.md

@@ -0,0 +1,32 @@
+# Troubleshooting
+
+The Instana gem has been designed to be fully automatic in process metric reporting and trace reporting.  But if something
+goes wrong, you can use the following steps and tips to potentially diagnose any issues that may exist.
+
+# Supported Components
+
+Make sure that the component that you want to get visibility into has been added to the support matrix.  A list of all
+supported components can be found in the [documentation](https://docs.instana.io/ecosystem/ruby/).
+
+# Logging & Environment Variables
+
+By default, the gem will log informational messages on boot that will indicate if any problems were encountered.  If you
+set the `INSTANA_DEBUG` environment variable, it will increase the amount of logging output.
+
+![instana console output](https://s3.amazonaws.com/instana/Instana+Ruby+boot+console+logging+output.png)
+
+In the example above, you can see that the host agent isn't available.  Once the host agent is available, the Instana
+gem will automatically re-connect without any intervention.
+
+There are even more methods to control logging output.  See the [Configuration](https://github.com/instana/ruby-sensor/blob/master/Configuration.md#logging)
+document for details.
+
+# Testing in your Application
+
+To diagnose the Instana gem from your application, often simply opening an application console with verbose logging can be
+enough to identify any potential issues:
+
+![rails console](https://s3.amazonaws.com/instana/Instana+Ruby+Rails+console+output.png)
+
+In the example above, you can see the Instana Ruby gem initialize, instrument some components and a success notification: `Host agent available. We're
+in business`.

data/benchmarks/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/instana/#{repo_name}" }
+
+gem "instana", :path => "~/Projects/instana/ruby-sensor"
+

data/benchmarks/id_generation.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require "bundler"
+Bundler.require(:default)
+
+require "benchmark"
+
+ID_RANGE = -2**63..2**63-1
+
+Benchmark.bm do |x|
+  x.report("generate_id raw    ")   { 1_000_000.times { rand(-2**63..2**63-1) } }
+  x.report("with fixed range   ")   { 1_000_000.times { rand(ID_RANGE) } }
+end

data/benchmarks/opentracing.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+require "bundler"
+Bundler.require(:default)
+
+require "benchmark"
+
+Benchmark.bm do |x|
+  x.report("start_span, finish:             ") {
+    50_000.times {
+      ::Instana.tracer.start_span(:blah).finish
+    }
+  }
+
+  x.report("start_span, set_tag(5x), finish:") {
+    50_000.times {
+      span = ::Instana.tracer.start_span(:blah)
+      span.set_tag(:blah, 1)
+      span.set_tag(:dog, 1)
+      span.set_tag(:moon, "ok")
+      span.set_tag(:ape, 1)
+      span.set_tag(:blah, 1)
+      span.finish
+    }
+  }
+
+end

data/benchmarks/rack_vanilla_vs_traced.rb

@@ -0,0 +1,80 @@
+require "bundler"
+
+require 'rack'
+require 'rack/builder'
+require 'rack/handler/puma'
+require 'net/http'
+require "benchmark"
+require "cgi"
+Bundler.require(:default)
+require "instana/rack"
+
+Thread.new do
+  app = Rack::Builder.new {
+    map "/" do
+      run Proc.new {
+        [200, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"scene!\"]"]]
+      }
+    end
+    map "/error" do
+      run Proc.new {
+        [500, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"error!\"]"]]
+      }
+    end
+  }
+
+  Rack::Handler::Puma.run(app, {:Host => '127.0.0.1', :Port => 7011})
+end
+
+Thread.new do
+  app = Rack::Builder.new {
+    use ::Instana::Rack
+    map "/" do
+      run Proc.new {
+        [200, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"scene!\"]"]]
+      }
+    end
+    map "/error" do
+      run Proc.new {
+        [500, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"error!\"]"]]
+      }
+    end
+  }
+
+  Rack::Handler::Puma.run(app, {:Host => '127.0.0.1', :Port => 7012})
+end
+
+sleep(2)
+puts "Rack server started in background thread on localhost:7011"
+puts "Sleeping for 10 to allow announce"
+sleep(10)
+
+
+puts "Starting benchmarks"
+Benchmark.bm do |x|
+
+  uri = URI.parse("http://127.0.0.1:7011/")
+  ::Net::HTTP.start(uri.host, uri.port) do |hc|
+    x.report("vanilla") {
+      1_000.times {
+        req = Net::HTTP::Get.new(uri.request_uri)
+        hc.request(req)
+      }
+    }
+  end
+
+  uri = URI.parse("http://127.0.0.1:7012/")
+  ::Net::HTTP.start(uri.host, uri.port) do |hc|
+    x.report("traced ") {
+      1_000.times {
+        ::Instana.tracer.start_or_continue_trace(:rack_call) do
+          req = Net::HTTP::Get.new(uri.request_uri)
+          hc.request(req)
+        end
+      }
+    }
+  end
+end
+
+
+sleep 10

data/benchmarks/stackprof_rack_tracing.rb

@@ -0,0 +1,77 @@
+require "bundler"
+require "stackprof"
+require 'rack'
+require 'rack/builder'
+require 'rack/handler/puma'
+require 'net/http'
+require "benchmark"
+require "cgi"
+Bundler.require(:default)
+require "instana/rack"
+
+Thread.new do
+  app = Rack::Builder.new {
+    map "/" do
+      run Proc.new {
+        [200, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"scene!\"]"]]
+      }
+    end
+    map "/error" do
+      run Proc.new {
+        [500, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"error!\"]"]]
+      }
+    end
+  }
+
+  Rack::Handler::Puma.run(app, {:Host => '127.0.0.1', :Port => 7011})
+end
+
+Thread.new do
+  app = Rack::Builder.new {
+    use ::Instana::Rack
+    map "/" do
+      run Proc.new {
+        [200, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"scene!\"]"]]
+      }
+    end
+    map "/error" do
+      run Proc.new {
+        [500, {"Content-Type" => "application/json"}, ["[\"Stan\",\"is\",\"on\",\"the\",\"error!\"]"]]
+      }
+    end
+  }
+
+  Rack::Handler::Puma.run(app, {:Host => '127.0.0.1', :Port => 7012})
+end
+
+sleep(2)
+puts "Rack server started in background thread on localhost:7011"
+puts "Sleeping for 10 to allow announce"
+sleep(10)
+
+puts "Starting profile"
+uri = URI.parse("http://127.0.0.1:7011/")
+StackProf.run(mode: :wall, out: 'tmp/stackprof-rack-vanilla.dump') do
+  ::Net::HTTP.start(uri.host, uri.port) do |hc|
+    5_000.times {
+      ::Instana.tracer.start_or_continue_trace(:rack_call) do
+        req = Net::HTTP::Get.new(uri.request_uri)
+        hc.request(req)
+      end
+    }
+  end
+end
+puts "stackprof tmp/stackprof-rack-vanilla.dump --text"
+
+uri = URI.parse("http://127.0.0.1:7012/")
+StackProf.run(mode: :wall, out: 'tmp/stackprof-rack-instrumented.dump') do
+  ::Net::HTTP.start(uri.host, uri.port) do |hc|
+    5_000.times {
+      ::Instana.tracer.start_or_continue_trace(:rack_call) do
+        req = Net::HTTP::Get.new(uri.request_uri)
+        hc.request(req)
+      end
+    }
+  end
+end
+puts "stackprof tmp/stackprof-rack-instrumented.dump --text"

data/benchmarks/time_processing.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require "bundler"
+Bundler.require(:default)
+
+require "benchmark"
+
+# Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+Benchmark.bm do |x|
+  x.report("Time.now:     ") { 1_000_000.times { (Time.now.to_f * 1000).floor } }
+  x.report("get_clocktime:") { 1_000_000.times { Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond) } }
+end

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "instana"
+
+require "pry"
+Pry.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/examples/opentracing.rb

@@ -0,0 +1,31 @@
+# This file contains a basic OpenTracing example.
+#
+# Note:  The instana gem automatically sets the Instana tracer
+# to `OpenTracing.global_tracer`.  Once the gem is loaded, you can
+# immediately start making OpenTracing calls.
+#
+require "opentracing"
+
+entry_span = OpenTracing.start_span("HandMadeRackServer")
+
+entry_span.set_tag(:'http.method', :get)
+entry_span.set_tag(:'http.url', "/users")
+entry_span.set_tag(:'span.kind', "entry")
+
+intermediate_span = OpenTracing.start_span("myintermediate", :child_of => entry_span)
+intermediate_span.finish()
+
+db_span = OpenTracing.start_span('mydbspan', :child_of => entry_span)
+db_span.set_tag(:'db.instance', "users")
+db_span.set_tag(:'db.statement', "SELECT * FROM user_table")
+db_span.set_tag(:'db.type', "mysql")
+db_span.set_tag(:'db.user', "mysql_login")
+db_span.set_tag(:'span.kind', "exit")
+db_span.finish()
+
+intermediate_span = OpenTracing.start_span("myintermediate", :child_of => entry_span)
+intermediate_span.log("ALLOK", :message => "All seems ok")
+intermediate_span.finish()
+
+entry_span.set_tag(:'http.status_code', 200)
+entry_span.finish()

data/examples/tracing.rb

@@ -0,0 +1,80 @@
+# This file outlines the Instana Ruby Tracing API.
+#
+# This same tracer also supports OpenTracing.  See `opentracing.rb` for
+# separate documentation.
+
+# This API is also documented on rubydoc:
+# http://www.rubydoc.info/gems/instana/1.7.8/Instana/Tracer
+
+#######################################
+## Block tracing
+#######################################
+
+#Instana::Tracer.start_or_continue_trace(name, kvs, incoming_context) - Initiates tracing
+#Instana::Tracer.trace(name, kvs) - starts a new span in an existing Trace
+
+# <start_or_continue_trace> will initiate a new trace.  Often used at entry
+# points in webservers (e.g. rack), it will initialize tracing and instrument the passed
+# block.  <incoming_id> is a hash for continuing remote traces (remote in terms
+# of service calls, or message queues).
+Instana::Tracer.start_or_continue_trace(:my_block_name, {}, incoming_context) do
+  # Code block
+end
+
+# <trace> will instrument a block of code in an already running trace.
+# This is the most common use case (instead of initiating new
+# traces).
+Instana::Tracer.trace(:postgres, {:user => 'postgres'}) do
+  @postgres.select(1)
+end
+
+#######################################
+## Lower level logging
+#######################################
+
+# <log_start_or_continue_trace> will initiate a new trace.  Often used at entry
+# points in webservers, it will establish a new trace (for web request,
+# background jobs etc.).
+# <incoming_context> is a hash for continuing remote traces (remote in terms
+# of service calls, or message queues).
+Instana::Tracer.log_start_or_continue(:rack, {}, incoming_context)
+
+# <log_entry> will start a new span from the current span within
+# a trace.
+Instana::Tracer.log_entry(name, kvs)
+
+# <log_exit> will close out the current span
+Instana::Tracer.log_exit(name, kvs)
+
+# <log_info> will append information to the current span in the
+# trace.  Examples could be redis options, contextual data, user
+# login status etc...
+Instana::Tracer.log_info({:some_key => 'some_value'})
+
+# <log_error> will log an exception to the current span in the
+# trace.
+Instana::Tracer.log_error(Exception)
+
+# <log_end> closes out the current span, finishes
+# the trace and adds it to ::Instana.processor
+# for reporting.
+Instana::Tracer.log_end(:rack, {})
+
+#######################################
+# Lower level API Example
+######################################
+
+# Full Tracing Lifecycle example
+#
+Instana::Tracer.log_start_or_continue(:mywebserver, {:user_id => @user_id})
+
+begin
+  Instana::Tracer.log_entry(:redis_lookup, {:redisdb => @redisdb.url})
+  @redisdb.get(@user_id.session_id)
+rescue => e
+  Instana::Tracer.log_error(e)
+ensure
+  Instana::Tracer.log_exit(:redis_lookup)
+end
+
+Instana::Tracer.log_end(:mywebserver)

data/gemfiles/libraries.gemfile

@@ -0,0 +1,71 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'rake'
+  gem 'minitest', '5.9.1'
+  gem 'minitest-reporters'
+  gem 'minitest-debugger', :require => false
+  gem 'rack-test'
+  gem 'webmock'
+  gem 'puma'
+  # public_suffix dropped support for Ruby 2.1 and earlier.
+  gem 'public_suffix', '< 3.0'
+end
+
+group :development do
+  gem 'ruby-debug',   :platforms => [:mri_18, :jruby]
+  gem 'debugger',     :platform  =>  :mri_19
+
+  if RUBY_VERSION > '1.8.7'
+    gem 'pry'
+
+    if RUBY_VERSION < '2.2'
+      gem 'byebug', '< 9.1.0'
+      gem 'pry-byebug'
+    else
+      gem 'pry-byebug'
+    end
+  else
+    gem 'pry', '0.9.12.4'
+  end
+end
+
+# Frameworks
+gem "sinatra", '1.4.7'
+gem "cuba"
+gem "roda"
+
+# gRPC
+gem 'grpc'
+
+# HTTP Clients
+gem 'rest-client'
+
+# Webservers
+gem "puma"
+
+# HTTP Clients
+gem 'excon'
+
+# Memcache
+gem 'dalli'
+gem 'redis'
+
+# Background Job queuing and processing
+if RUBY_VERSION < '2.2'
+  gem 'sidekiq', '~> 4.2.10'
+else
+  gem 'sidekiq', '> 5.0'
+end
+
+gem 'resque'
+
+# Rack v2 dropped support for Ruby 2.2 and higher.
+if RUBY_VERSION < '2.2'
+  gem 'rack', '< 2.0'
+end
+
+# Include the Instana Ruby gem's base set of gems
+gemspec :path => File.expand_path(File.dirname(__FILE__) + '/../')
+
+# vim:syntax=ruby