instana 1.10.1-java

data/.travis.yml

@@ -0,0 +1,43 @@
+language: ruby
+
+cache:
+  bundler: true
+  directories:
+    - vendor/bundle
+
+rvm:
+  - 2.5
+  - 2.4
+
+before_install:
+  - gem update --system
+  - gem install bundler
+  - gem --version
+
+before_script:
+  - psql -c 'create database travis_ci_test;' -U postgres
+  - mysql -e 'CREATE DATABASE travis_ci_test;'
+
+script: "bundle exec rake test"
+
+services:
+  - memcached
+  - redis
+  - mysql
+  - postgresql
+
+gemfile:
+  - Gemfile
+  - gemfiles/libraries.gemfile
+  - gemfiles/rails50.gemfile
+
+matrix:
+  exclude:
+    # Rails 5.0+ requires Ruby 2.2.2 or higher
+    - rvm: 2.1.10
+      gemfile: gemfiles/rails50.gemfile
+
+notifications:
+  slack:
+    rooms:
+      secure: Ae9tJmBO9/sgYWthHRS5uufAf8s6uIMdtmQn+gBkcAXaMWJgt1IAzpIj98Qsg15/lhHS8ezwCe7WIAWC4mM1cnwl/hP195dbgLzF4D2uOjaIXj55ckIIE06jBX1yHapu0vMFSaKwgL4auEEVg4xkehBb9TzLNG/LbExadZQOIkeLdtgU04VrPfDC9pZWPplXT4kzjMZkMESzBYaCfNl6eenu0sHdoxSvngv52MImog6aZQKT+k3ccAa1yzZNhUdy4gSZi1HafXdSCn4UTPDtkNIlsWBW8yprICLxZV/NvgUTEEJYSHO6Ucx9Er22LzKtNbEYlAs1GErGWjDzpqvvXt/5UwNx0rLDrVKI/xMIELEbT047mSgJ8tpVd0ErGA/bnDfbF2oDFTAEXq4jaeAMaVR9Q1CW0ZZF2Jh5jOKc41U+AVGgaMDaBA0ukDSeXvJcnteZ9EllOO8ZAtC2FKtBNnj36W13KTR0TkjMCl+KOiVJXnOyRJIR+CUL9BdDuODBVPZHqZaZ48N+MOG9dRb+fvkdTnwh7hU+UmR08kOsd4x+dDlm4dBrFrB8v8udQ7XuBN9AOZty2CPWFUSJM1BxtetyS3We0L6lQ8o/B9STFNK4KTa/M8wNq1Fm85h3ZKHHIHDpQnXM6vD8SV1p9u91C5UI8rEyxzW5IaT2oqXsCzU=

data/Configuration.md

@@ -0,0 +1,149 @@
+# Configuration
+
+## Global Enable/Disable
+
+The entire gem can be disabled at runtime with:
+
+```Ruby
+::Instana.config[:enabled] = false # default: true
+```
+
+Other global enable/disable options are:
+
+```Ruby
+# Enable/Disable metrics collection and reporting
+Instana.config[:metrics][:enabled] # default true
+
+# Enable/Disable tracing
+Instana.config[:tracing][:enabled] # default true
+```
+
+If you wish to disable the built-in instrumentation but still permit custom instrumentation, set the following environment variable for your application:
+
+```sh
+export INSTANA_DISABLE_AUTO_INSTR=true
+```
+
+## Agent Communication
+
+The sensor tries to communicate with the Instana agent via IP 127.0.0.1 and as a fallback via the host's default gateway. Should the agent not be available under either of these IPs, e.g. due to iptables or other networking tricks, you can use the agentHost option to use a custom IP.
+
+```Ruby
+# Leverage environment variable
+::Instana.config[:agent_host] = ENV['INSTANA_AGENT_HOST']
+
+# Custom agent port
+::Instana.config[:agent_port] = 42699
+```
+
+## Enabling/Disabling Individual Components
+
+Individual components can be enabled and disabled with a local config.
+
+To disable a single component in the gem, you can disable a single component with the following code:
+
+```Ruby
+::Instana.config[:metrics][:gc][:enabled] = false
+```
+Current metric components are `:gc`, `:memory` and `:thread`.
+
+Instrumentation can be disabled as:
+
+```Ruby
+::Instana.config[:excon][:enabled] = false
+::Instana.config[:rack][:enabled] = false
+```
+
+## Enable/Disable Backtrace Collection
+
+Because backtraces are somewhat expensive in Ruby, backtrace collection is disabled by default but can be enabled with the following code:
+
+```Ruby
+::Instana.config[:collect_backtraces] = true
+```
+
+This will in-turn enable CodeView in your dashboard to get code level insights.
+
+## Setting a Custom Service Name
+
+You can set a custom service name for your application by setting the `INSTANA_SERVICE_NAME` environment variable:
+
+```sh
+export INSTANA_SERVICE_NAME=MrBlueSky
+```
+
+## Rack Middleware
+
+This gem will detect and automagically insert the Instana Rack middleware into the middleware stack when a [supported framework](https://docs.instana.io/ecosystem/ruby/) is present.  We are currently adding support for more frameworks.  If you are using a yet to be instrumented framework, you can insert the Instana Rack middleware with the following:
+
+```Ruby
+require "instana/rack"
+config.middleware.use ::Instana::Rack
+```
+
+...or whatever specific middleware call is appropriate for your framework.
+
+
+## Managing the Agent Background Thread
+
+This agent spawns a lightweight background thread to periodically collect and report metrics and traces.  Be default, this uses a standard Ruby thread.  If you wish to have greater control and potentially boot the agent reporting manually in an alternative thread system (such as actor based threads), you can do so with the following:
+
+```Ruby
+gem "instana", :require => "instana/setup"
+```
+
+...then in the background thread of your choice simply call:
+
+```Ruby
+::Instana.agent.start
+```
+
+Note that this call is blocking.  It kicks off a loop of timers that periodically collects and reports metrics and trace data.  This should only be called from inside an already initialized background thread:
+
+```Ruby
+Thread.new do
+  ::Instana.agent.start
+end
+```
+
+### Caveat
+
+In the case of forking web servers such as Unicorn or Puma in clustered mode, the agent detects the pid change and re-spawns the background thread.  If you are managing the background thread yourself with the steps above _and_ you are using a forking webserver (or anything else that may fork the original process), you should also do the following.
+
+When a fork is detected, the agent handles the re-initialization and then calls `::Agent.instana.spawn_background_thread`.  This by default uses the standard `Thread.new`.  If you wish to control this, you should override this method by re-defining that method.  For example:
+
+```ruby
+# This method can be overridden with the following:
+#
+module Instana
+  class Agent
+    def spawn_background_thread
+      # start/identify custom thread
+      ::Instana.agent.start
+    end
+  end
+end
+```
+
+## Logging
+
+The Instana logger is a standard Ruby logger that logs debug, warn, info
+(etc.) messages and can be set as follows:
+
+```Ruby
+require "logger"
+::Instana.logger.level = ::Logger::WARN
+```
+
+The gem can be configured to use your application logger instead:
+
+```
+::Instana.logger = ::Rails.logger
+```
+
+### Debugging & More Verbosity
+
+#### Environment Variable
+
+Setting `INSTANA_DEBUG` to a non nil value will enable extra logging output generally useful
+for development.

data/Dockerfile

@@ -0,0 +1,13 @@
+# For development/testing, you can run this instrumentation
+# interactively in a Docker container:
+# docker build -t instana/ruby-sensor-console:0.1
+# docker run -it instana/ruby-sensor-console:0.1
+#
+FROM ruby:2.3.1
+RUN apt-get update -qq && apt-get install -y build-essential libpq-dev nodejs openssh-client git vim zip curl uni2ascii bsdmainutils
+RUN mkdir /ruby-sensor
+WORKDIR /ruby-sensor
+COPY Gemfile Gemfile.lock instana.gemspec ./
+COPY . ./
+RUN gem install bundler && bundle install --jobs 20 --retry 5
+CMD bundle exec rake console

data/Gemfile

@@ -0,0 +1,41 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'rake'
+  gem 'minitest', '5.9.1'
+  gem 'minitest-reporters'
+  gem 'minitest-debugger', :require => false
+  gem 'webmock'
+  gem 'puma'
+
+  # Rack v2 dropped support for Ruby 2.2 and higher.
+  if RUBY_VERSION < '2.2'
+    gem 'rack', '~> 1.6'
+  end
+  gem 'rack-test'
+
+  # 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
+  gem 'stackprof',    :platform  =>  [:mri_19, :mri_20]
+
+  if RUBY_VERSION > '1.8.7'
+    gem 'pry'
+
+    if RUBY_VERSION < '2.2'
+      gem 'byebug', '< 9.1.0', :platform  =>  [:mri_19, :mri_20]
+      gem 'pry-byebug', :platform  =>  [:mri_19, :mri_20]
+    else
+      gem 'pry-byebug', :platform  =>  [:mri_19, :mri_20]
+    end
+  else
+    gem 'pry', '0.9.12.4'
+  end
+end
+
+# instana.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Instana
+
+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/README.md

@@ -0,0 +1,102 @@
+<div align="center">
+<img src="http://www.instana.com/wp-content/uploads/2016/11/Instana-Infrastructure-Map-1-1024x551.png"/>
+</div>
+
+# Instana
+
+The Instana gem provides Ruby metrics and traces (request, queue & cross-host) for [Instana](https://www.instana.com/).
+
+[![Build Status](https://travis-ci.org/instana/ruby-sensor.svg?branch=master)](https://travis-ci.org/instana/ruby-sensor)
+[![Code
+Climate](https://codeclimate.com/github/instana/ruby-sensor/badges/gpa.svg)](https://codeclimate.com/github/instana/ruby-sensor)
+[![Gem Version](https://badge.fury.io/rb/instana.svg)](https://badge.fury.io/rb/instana)
+[![OpenTracing Badge](https://img.shields.io/badge/OpenTracing-enabled-blue.svg)](http://opentracing.io)
+
+## Note
+
+This gem supports Ruby versions 2.0 or greater.
+
+Any and all feedback is welcome.  Happy Ruby visibility.
+
+[![rails](https://s3.amazonaws.com/instana/rails-logo.jpg?1)](http://rubyonrails.org/)
+[![roda](https://s3.amazonaws.com/instana/roda-logo.png?1)](http://roda.jeremyevans.net/)
+[![cuba](https://s3.amazonaws.com/instana/cuba-logo.png?1)](http://cuba.is/)
+[![mina logo 100px](https://cloud.githubusercontent.com/assets/395132/23832558/fcd5bdb2-0736-11e7-9809-3016e89698e2.png)](https://github.com/instana/mina-instana)
+[![sinatra](https://s3.amazonaws.com/instana/sinatra-logo.png?1)](http://www.sinatrarb.com/)
+[![padrino](https://s3.amazonaws.com/instana/padrino-logo.png?1)](http://padrinorb.com/)
+[![rack](https://s3.amazonaws.com/instana/rack-logo.png?1)](https://rack.github.io/)
+[![rack](https://user-images.githubusercontent.com/395132/27842764-27e0e452-610d-11e7-811f-8575f83b8944.png?1)](http://www.grpc.io/)
+
+## Installation
+
+The gem is available on [Rubygems](https://rubygems.org/gems/instana).  To install, add this line to _the end_ of your application's Gemfile:
+
+```ruby
+gem 'instana'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install instana
+
+## Usage
+
+The instana gem is a zero configuration tool that will automatically collect key metrics from your Ruby processes.  Just install and go.
+
+## Configuration
+
+Although the gem has no configuration required for out of the box metrics and tracing, components can be configured if needed.  See [Configuration.md](https://github.com/instana/ruby-sensor/blob/master/Configuration.md).
+
+## Tracing
+
+This Ruby gem provides a simple API for tracing and also supports [OpenTracing](http://opentracing.io/).  See [Tracing.md](https://github.com/instana/ruby-sensor/blob/master/Tracing.md) for details.
+
+## Documentation
+
+You can find more documentation covering supported components and minimum versions in the Instana [documentation portal](https://docs.instana.io/ecosystem/ruby/).
+
+## Want End User Monitoring?
+
+Instana provides deep end user monitoring that links server side traces with browser events.  
+
+For Ruby templates and views, get your EUM API key from your Instana dashboard and you can call `::Instana::Helpers.eum_snippet('example_api_key_string')` from within your layout file.  This will output
+a small javascript snippet of code to instrument browser events.  It's based on [Weasel](https://github.com/instana/weasel).  Check it out.
+
+As an example for Haml, you could do the following:
+
+```ruby
+%html{ :lang => "en", :xmlns => "http://www.w3.org/1999/xhtml" }
+  %head
+    - if user_signed_in?
+      = raw ::Instana::Helpers.eum_snippet('example_api_key_string', :username => current_user.username)
+    - else
+      = raw ::Instana::Helpers.eum_snippet('example_api_key_string')
+  %body
+```
+Make sure to use the `raw` helper so the javascript isn't interpolated with escape strings.
+
+The optional second argument to `::Instana::Helpers.eum_snippet` is a hash of metadata key/values that will be reported along
+with the browser instrumentation.
+
+![Instana EUM example with metadata](https://s3.amazonaws.com/instana/Instana+Gameface+EUM+with+metadata+2016-12-22+at+15.32.01.png)
+
+See also the [End User Monitoring](https://docs.instana.io/products/website_monitoring/) in the Instana documentation portal.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/instana/ruby-sensor.
+
+## More
+
+Want to instrument other languages?  See our [Nodejs instrumentation](https://github.com/instana/nodejs-sensor), [Go instrumentation](https://github.com/instana/golang-sensor) or [many other supported technologies](https://www.instana.com/supported-technologies/).
+

data/Rakefile

@@ -0,0 +1,56 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.verbose = false
+  t.warning = false
+  t.ruby_opts = []
+
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+
+  if ENV.key?('BUNDLE_GEMFILE')
+    case File.basename(ENV['BUNDLE_GEMFILE']).split('.').first
+    when /rails50/
+      t.test_files = %w(test/frameworks/rails/activerecord5_test.rb
+                        test/frameworks/rails/actioncontroller_test.rb
+                        test/frameworks/rails/actionview5_test.rb)
+    when /rails42/
+      t.test_files = %w(test/frameworks/rails/activerecord4_test.rb
+                        test/frameworks/rails/actioncontroller_test.rb
+                        test/frameworks/rails/actionview4_test.rb)
+    when /rails32/
+      t.test_files = %w(test/frameworks/rails/activerecord3_test.rb
+                        test/frameworks/rails/actioncontroller_test.rb
+                        test/frameworks/rails/actionview3_test.rb)
+    when /libraries/
+      t.test_files = FileList['test/instrumentation/*_test.rb',
+                              'test/frameworks/cuba_test.rb',
+                              'test/frameworks/roda_test.rb',
+                              'test/frameworks/sinatra_test.rb']
+    else
+      t.test_files = FileList['test/agent/*_test.rb'] +
+                     FileList['test/tracing/*_test.rb'] +
+                     FileList['test/profiling/*_test.rb'] +
+                     FileList['test/benchmarks/bench_*.rb']
+    end
+  else
+    t.test_files = FileList['test/agent/*_test.rb'] +
+        FileList['test/tracing/*_test.rb'] +
+        FileList['test/profiling/*_test.rb'] +
+        FileList['test/benchmarks/bench_*.rb']
+  end
+end
+
+task :environment do
+  ENV['INSTANA_DEBUG'] = 'true'
+  Bundler.require(:default, :development)
+end
+
+task :console => :environment do
+  ARGV.clear
+  Pry.start
+end
+
+task :default => :spec

data/Tracing.md

@@ -0,0 +1,145 @@
+# Tracing
+
+Tracing with Instana is automatic but if you want even more visibility into custom code or some in-house
+component, you can use Instana's tracing API or [OpenTracing](http://opentracing.io/).
+
+# OpenTracing
+
+Existing applications that utilize the OpenTracing API or those who wish to add support should have no problem
+as the Instana Ruby gem fully supports the OpenTracing specification.
+
+To start, simply set the Instana tracer as the global tracer for OpenTracing:
+
+```Ruby
+require 'opentracing'
+OpenTracing.global_tracer = ::Instana.tracer
+```
+
+Then OpenTracing code can be run normally:
+
+```Ruby
+begin
+  span = OpenTracing.start_span('job')
+  # The code to be instrumented
+  @id = User.find_by_name('john.smith')
+  span.set_tag(:job_id, @id)
+rescue => e
+  span.set_tag(:error, e.message)
+ensure
+  span.finish
+end
+```
+
+# The Instana Ruby API
+
+The Instana Ruby gem provides a simple to use API to trace any arbitrary part of your application.
+
+To instrument a section of code, it can be simply done with:
+
+```Ruby
+begin
+  ::Instana.tracer.log_entry(:mywork, { :helpful_kvs => @user.id })
+  # The code to be instrumented
+  @id = User.find_by_name('john.smith')
+rescue => e
+  ::Instana.tracer.log_error(e)
+ensure
+  ::Instana.tracer.log_exit(:mywork, { :found_id => @id })
+end
+```
+
+or alternatively you can use the `trace` block method that will automagically capture and
+log any exceptions raised:
+
+```Ruby
+::Instana.tracer.trace(:mywork, { :helpful_kvs => @user.id }) do
+  # The code to be instrumented
+  @id = User.find_by_name('john.smith')
+ end
+```
+
+The above are simple examples but shows how easy it is to instrument any arbitrary piece of code you like.
+
+See the [examples directory](https://github.com/instana/ruby-sensor/blob/master/examples/tracing.rb) for
+an expanded view and quick cheat sheet on tracing.
+
+# Asynchronous Tracing
+
+Some operations that you want to trace might be asynchronous meaning that they may return immediately
+but will still continue to work out of band.  To do this, you can use  the `log_async_*` related 
+tracing methods:
+
+```Ruby
+::Instana.tracer.log_entry(:prep_job, { :helpful_kvs => @job.name })
+
+http_ops = {:get => "/", :post => "/post_data"}
+
+cb_block = Proc.new do |response, payload|
+  # The callback block that is invoked on HTTP response (payload == t_context)
+  #
+  # process response
+  #
+  ::Instana.tracer.log_async_exit(:http_op, :status => response.status, payload)
+end
+
+http_ops.each do |op|
+  t_context = ::Instana.tracer.log_async_entry(:http_op)
+  
+  # Example op that returns immediately
+  request_id = connection.async_request(op, cb_block, t_context)
+  
+  ::Instana.tracer.log_async_info({:request_id => request_id}, t_context)
+end  
+```
+
+# Carrying Context into New Threads
+
+Tracing is thread local.  If you spawn a new thread the context must be carried to that new thread and then picked up.
+
+```Ruby
+# Get the tracing context
+t_context = ::Instana.tracer.context
+
+# Spawn new thread
+Thread.new do
+  # Pickup context in this thread with `t_context`
+  ::Instana.tracer.log_start_or_continue(:async_thread, { :async_start => 1 }, t_context)
+  
+  # Continue tracing work as usual
+  begin
+    ::Instana.tracer.log_entry(:mywork, { :helpful_kvs => @user.id })
+    # The code to be instrumented
+    @id = User.find_by_name('john.smith')
+  rescue => e
+    ::Instana.tracer.log_error(e)
+  ensure
+    ::Instana.tracer.log_exit(:mywork, { :found_id => @id })
+  end
+end
+```
+# Tracing Jobs Scheduled for Later
+
+Jobs that are queued to be run later can be instrumented as such:
+
+```Ruby
+::Instana.tracer.log_entry(:prep_job, { :job_name => @job.name })
+
+# Get the current tracing context
+t_context = ::Instana.tracer.context
+
+# The Async proc (job) that will be executed out of band.
+block = Proc.new do 
+  # This will pickup context and link the two traces (root + job)
+  t_context = ::Instana.tracer.log_start_or_continue_trace(:my_async_op, { :helpful_kvs => true }, t_context)
+  #
+  # Some Asynchronous work to be done
+  #
+  ::Instana.tracer.log_info({:job_name => Job.get(id).name})
+  # More Asynchronous work
+  ::Instana.tracer.log_end(:my_async_op, { :job_success => true })
+end
+
+MyClass.run_in_5_minutes(block)
+
+::Instana.tracer.log_exit(:prep_job, { :prep_successful => true })
+```