traceview 3.0.5-java → 3.1.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ed3821a6292705e02ec4fff2d84e34da9c7c9cc
-  data.tar.gz: 5a033d814244dddae9e137c8bb23d76aeb56fbd0
+  metadata.gz: 7ab475ce550edae53924cbe72eaf7b93e337df71
+  data.tar.gz: 12ee03213258aa59f4fd7641247db417833cde06
 SHA512:
-  metadata.gz: fdb1e46cba04472ffa486012fef5da31cdb4c37a9bed5ecb7df10dab556b166b91818f86333cdff8b600fd962678f3d154f6749eb41fbeb5d83b0c53f69da422
-  data.tar.gz: 99f0b8bd3725297a5395c2fab358bba7cd3fb31c1f2fb5cc5a1f8da6312250f665082d2026cbf76508406487adc1f50da97671d169b89fc0ffd90cf6e192e514
+  metadata.gz: c3f934605ce6a37c9e5b11d6d9490a01c279b104b6a4fe055bc8db4f76d63bf95df4591081b81534d8505d4c2fc2b5bffab4227bb1b6340253df5c03a6742943
+  data.tar.gz: c4a2ea84c0a5e861f7878304fb59aa66d3f9f47165bc909dd25ff95c74f745cd72984473d6e5955f8f3ceb9357a16a2b9f48715bd461bbe3ea546e62a33e8a20

data/CHANGELOG.md

@@ -4,6 +4,29 @@ https://github.com/appneta/oboe-ruby/releases
 
 Dates in this file are in the format MM/DD/YYYY.
 
+# traceview 3.1.0
+
+This minor release adds the following:
+
+* New Curb HTTP client instrumentation: #132
+
+Pushed to Rubygems:
+
+https://rubygems.org/gems/traceview/versions/3.1.0
+https://rubygems.org/gems/traceview/versions/3.1.0-java
+
+# traceview 3.0.5
+
+This patch release includes the following fixes:
+
+* Fix "undefined method" in httpclient instrumentation: #134
+* Fix Redis set operation to work with array versus hash: #133
+
+Pushed to Rubygems:
+
+https://rubygems.org/gems/traceview/versions/3.0.5
+https://rubygems.org/gems/traceview/versions/3.0.5-java
+
 # traceview 3.0.4
 
 This patch release includes the following fixes:

data/README.md

@@ -32,6 +32,8 @@ On Heroku?  Use the `oboe-heroku` gem instead.  It wraps some additional functio
 
 ## Rails
 
+![Ruby on Rails](http://www.appneta.com/images/logos/frameworks/rails.png)
+
 No special steps are needed to instrument Ruby on Rails.  Once part of the bundle, the traceview gem will automatically detect Rails and instrument on stack initialization.
 
 *Note: Unless you are Heroku, you will still need to decide on your `tracing_mode` depending on whether you are running with an instrumented Apache or nginx in front of your Rails stack.  See below for more details.*
@@ -50,6 +52,8 @@ After the prompts, this will create an initializer: `config/initializers/tracevi
 
 ## Sinatra
 
+![Sinatra](http://www.appneta.com/images/logos/frameworks/sinatra.png)
+
 You can instrument your Sinatra application by adding the following code to your `config.ru` Rackup file:
 
 ```ruby
@@ -75,6 +79,8 @@ With this, the traceview gem will automatically detect Sinatra on boot and instr
 
 ## Padrino
 
+![Padrino](http://www.appneta.com/images/logos/frameworks/padrino.png)
+
 As long as the traceview gem is in your `Gemfile` (inserted after the `gem 'padrino'` directive) and you are calling `Bundler.require`, the traceview gem will automatically instrument Padrino applications.
 
 If you need to set `TraceView::Config` values on stack boot, you can do so by adding the following
@@ -94,6 +100,8 @@ Note: If you're on Heroku, you don't need to set `tracing_mode` - it will be aut
 
 ## Grape
 
+![Grape](http://www.appneta.com/images/logos/frameworks/grape.png)
+
 You can instrument your Grape application by adding the following code to your `config.ru` Rackup file:
 
 ```ruby
@@ -351,6 +359,8 @@ You can read more about Ruby gems with C extensions in the [Rubygems Guides](htt
 
 ## Running the Tests
 
+![TraceView Ruby Tests](https://s3.amazonaws.com/appneta/tv_ruby_tests.png)
+
 The tests bundled with the gem are implemented using [Minitest](https://github.com/seattlerb/minitest).  The tests are currently used to validate the sanity of the traces generated and basic gem functionality.
 
 After a bundle install, the tests can be run as:

data/gemfiles/libraries.gemfile

@@ -43,17 +43,18 @@ else
   gem 'sinatra'
 end
 
+gem 'cassandra'
+gem 'curb'
 gem 'dalli'
+gem 'excon'
+gem 'faraday'
+gem 'httpclient'
 gem 'memcache-client'
-gem 'cassandra'
 gem 'mongo'
-gem 'resque'
 gem 'redis'
-gem 'faraday'
-gem 'httpclient'
-gem 'excon'
-gem 'typhoeus'
+gem 'resque'
 gem 'sequel'
+gem 'typhoeus'
 
 # Database adapter gems needed by sequel
 if defined?(JRUBY_VERSION)

data/lib/oboe_metal.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2013 AppNeta, Inc.
 # All rights reserved.
 
+require 'thread'
+
 # Disable docs and Camelcase warns since we're implementing
 # an interface here.  See OboeBase for details.
 # rubocop:disable Style/Documentation, Style/MethodName
@@ -149,3 +151,4 @@ end
 # rubocop:enable Style/Documentation
 
 TraceView.loaded = true
+TraceView.config_lock = Mutex.new

data/lib/rails/generators/traceview/templates/traceview_initializer.rb

@@ -97,6 +97,7 @@ if defined?(TraceView::Config)
   # TraceView::Config[:active_record][:enabled] = true
   # TraceView::Config[:action_view][:enabled] = true
   # TraceView::Config[:cassandra][:enabled] = true
+  # TraceView::Config[:curb][:enabled] = true
   # TraceView::Config[:dalli][:enabled] = true
   # TraceView::Config[:excon][:enabled] = true
   # TraceView::Config[:em_http_request][:enabled] = true
@@ -126,6 +127,7 @@ if defined?(TraceView::Config)
   # TraceView::Config[:active_record][:collect_backtraces] = true
   # TraceView::Config[:action_view][:collect_backtraces] = true
   # TraceView::Config[:cassandra][:collect_backtraces] = true
+  # TraceView::Config[:curb][:collect_backtraces] = true
   # TraceView::Config[:dalli][:collect_backtraces] = false
   # TraceView::Config[:excon][:collect_backtraces] = false
   # TraceView::Config[:em_http_request][:collect_backtraces] = true
@@ -143,6 +145,22 @@ if defined?(TraceView::Config)
   # TraceView::Config[:typhoeus][:collect_backtraces] = false
   #
 
+  # By default, the curb instrumentation will not link
+  # outgoing requests with remotely instrumented
+  # webservers (aka cross host tracing).  This is because the
+  # instrumentation can't detect if the independent libcurl
+  # instrumentation is in use or not.
+  #
+  # If you're sure that it's not in use/installed, then you can
+  # enable cross host tracing for the curb HTTP client
+  # here.  Set TraceView::Config[:curb][:cross_host] to true
+  # to enable.
+  #
+  # Alternatively, if you would like to install the separate
+  # libcurl instrumentation, see here:
+  # http://docs.appneta.com/installing-libcurl-instrumentation
+  # TraceView::Config[:curb][:cross_host] = false
+
   #
   # Resque Options
   #

data/lib/traceview/base.rb

@@ -35,6 +35,9 @@ module TraceViewBase
   thread_local :sample_rate
   thread_local :layer
   thread_local :layer_op
+  # Semaphore used during the test suite to test
+  # global config options.
+  thread_local :config_lock
 
   # The following accessors indicate the incoming tracing state received
   # by the rack layer.  These are primarily used to identify state
@@ -191,6 +194,34 @@ module TraceViewBase
     end
   end
 
+  ##
+  # Debugging helper method
+  #
+  def pry!
+    # Only valid for development or test environments
+    env = ENV['RACK_ENV'] || ENV['RAILS_ENV']
+    return unless [ "development", "test" ].include? env
+
+    if RUBY_VERSION > '1.8.7'
+      require 'pry-byebug'
+
+      if defined?(PryByebug)
+        Pry.commands.alias_command 'c', 'continue'
+        Pry.commands.alias_command 's', 'step'
+        Pry.commands.alias_command 'n', 'next'
+        Pry.commands.alias_command 'f', 'finish'
+
+        Pry::Commands.command /^$/, "repeat last command" do
+          _pry_.run_command Pry.history.to_a.last
+        end
+      end
+
+      binding.pry
+    else
+      require 'ruby-debug'; debugger
+    end
+  end
+
   ##
   # Indicates whether a supported framework is in use
   # or not
@@ -227,3 +258,4 @@ end
 # Setup an alias so we don't bug users
 # about single letter capitalization
 Traceview = TraceView
+TV = TraceView

data/lib/traceview/config.rb

@@ -12,13 +12,13 @@ module TraceView
     @@config = {}
 
     @@instrumentation = [:action_controller, :action_view, :active_record,
-                         :cassandra, :dalli, :em_http_request, :excon, :faraday,
+                         :cassandra, :curb, :dalli, :em_http_request, :excon, :faraday,
                          :grape, :httpclient, :nethttp, :memcached, :memcache, :mongo,
                          :moped, :rack, :redis, :resque, :rest_client, :sequel,
                          :typhoeus]
 
     # Subgrouping of instrumentation
-    @@http_clients = [:excon, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
+    @@http_clients = [:curb, :excon, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
 
     ##
     # Return the raw nested hash.
@@ -44,6 +44,7 @@ module TraceView
       TraceView::Config[:active_record][:collect_backtraces] = true
       TraceView::Config[:action_view][:collect_backtraces] = true
       TraceView::Config[:cassandra][:collect_backtraces] = true
+      TraceView::Config[:curb][:collect_backtraces] = true
       TraceView::Config[:dalli][:collect_backtraces] = false
       TraceView::Config[:em_http_request][:collect_backtraces] = false
       TraceView::Config[:excon][:collect_backtraces] = true
@@ -146,6 +147,22 @@ module TraceView
       # report all raised exception regardless.
       @@config[:report_rescued_errors] = false
 
+      # By default, the curb instrumentation will not link
+      # outgoing requests with remotely instrumented
+      # webservers (aka cross host tracing).  This is because the
+      # instrumentation can't detect if the independent libcurl
+      # instrumentation is in use or not.
+      #
+      # If you're sure that it's not in use/installed, then you can
+      # enable cross host tracing for the curb HTTP client
+      # here.  Set TraceView::Config[:curb][:cross_host] to true
+      # to enable.
+      #
+      # Alternatively, if you would like to install the separate
+      # libcurl instrumentation, see here:
+      # http://docs.appneta.com/installing-libcurl-instrumentation
+      @@config[:curb][:cross_host] = false
+
       # Environment support for OpenShift.
       if ENV.key?('OPENSHIFT_TRACEVIEW_TLYZER_IP')
         # We're running on OpenShift

data/lib/traceview/inst/curb.rb

@@ -0,0 +1,281 @@
+# Copyright (c) 2015 AppNeta, Inc.
+# All rights reserved.
+
+module TraceView
+  module Inst
+
+    # Curb instrumentation wraps instance and class methods in two classes:
+    # Curl::Easy and Curl::Multi.  This CurlUtility module is used as a common module
+    # to be shared among both modules.
+    module CurlUtility
+
+      ##
+      # traceview_collect
+      #
+      # Used as a central area to retrieve and return values
+      # that we're interesting in reporting to TraceView
+      #
+      def traceview_collect(verb = nil)
+        kvs = {}
+
+        if TraceView::Config[:curb][:cross_host]
+          kvs['IsService'] = 1
+
+          # Conditionally log query args
+          if TraceView::Config[:curb][:log_args]
+            kvs[:RemoteURL] = url
+          else
+            kvs[:RemoteURL] = url.split('?').first
+          end
+
+          kvs[:HTTPMethod] = verb if verb
+        end
+
+        # Avoid cross host tracing for blacklisted domains
+        kvs[:blacklisted] = TraceView::API.blacklisted?(URI(url).hostname)
+        kvs['Backtrace'] = TraceView::API.backtrace if TraceView::Config[:curb][:collect_backtraces]
+
+        kvs
+      rescue => e
+        TraceView.logger.debug "[traceview/debug] Error capturing curb KVs: #{e.message}"
+        TraceView.logger.debug e.backtrace.join('\n') if ::TraceView::Config[:verbose]
+      end
+
+      ##
+      # profile_curb_method
+      #
+      # An agnostic method that will profile any Curl::Easy method (and optional args and block)
+      # that you throw at it.
+      #
+      def profile_curb_method(kvs, method, args, &block)
+        # If we're not tracing, just do a fast return.
+        return self.send(method, args, &block) if !TraceView.tracing?
+
+        begin
+          response_context = nil
+          req_context = nil
+          handle_cross_host = TraceView::Config[:curb][:cross_host]
+          kvs.merge! traceview_collect
+
+          TraceView::API.log_entry('curb', kvs)
+          kvs.clear
+
+          if handle_cross_host && !kvs[:blacklisted]
+            req_context = TraceView::Context.toString()
+            self.headers['X-Trace'] = req_context
+          end
+
+          # The core curb call
+          response = self.send(method, *args, &block)
+
+          if handle_cross_host
+            kvs['HTTPStatus'] = response_code
+
+            # If we get a redirect, report the location header
+            if ((300..308).to_a.include? response_code) && headers.key?("Location")
+              kvs["Location"] = headers["Location"]
+            end
+
+            # Curb only provides a single long string of all response headers (yuck!).  So we are forced
+            # to process that string to pull out the response X-Trace value.
+            # Taken from https://stackoverflow.com/questions/14345805/curb-get-response-headers
+            _, *response_headers = header_str.split(/[\r\n]+/).map(&:strip)
+            response_headers = Hash[response_headers.flat_map{ |s| s.scan(/^(\S+): (.+)/) }]
+
+            response_context = response_headers['X-Trace']
+            if response_context && !kvs[:blacklisted]
+              TraceView::XTrace.continue_service_context(req_context, response_context)
+            end
+          end
+
+          response
+        rescue => e
+          TraceView::API.log_exception('curb', e)
+          raise e
+        ensure
+          TraceView::API.log_exit('curb', kvs)
+        end
+
+      end
+    end # CurlUtility
+
+    # Instrumentation specific to ::Curl::Easy
+    module CurlEasy
+      # Common methods
+      include TraceView::Inst::CurlUtility
+
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :http, ::Curl::Easy)
+        ::TraceView::Util.method_alias(klass, :perform, ::Curl::Easy)
+        ::TraceView::Util.method_alias(klass, :http_put, ::Curl::Easy)
+        ::TraceView::Util.method_alias(klass, :http_post, ::Curl::Easy)
+      end
+
+      ##
+      # http_post_with_traceview
+      #
+      # ::Curl::Easy.new.http_post wrapper
+      #
+      def http_post_with_traceview(*args, &block)
+        # If we're not tracing, just do a fast return.
+        if !TraceView.tracing? || TraceView.tracing_layer?('curb')
+          return http_post_without_traceview(*args)
+        end
+
+        kvs = {}
+        if TraceView::Config[:curb][:cross_host]
+          kvs[:HTTPMethod] = :POST
+        end
+
+        profile_curb_method(kvs, :http_post_without_traceview, args, &block)
+      end
+
+      ##
+      # http_put_with_traceview
+      #
+      # ::Curl::Easy.new.http_put wrapper
+      #
+      def http_put_with_traceview(*args, &block)
+        # If we're not tracing, just do a fast return.
+        if !TraceView.tracing? || TraceView.tracing_layer?('curb')
+          return http_put_without_traceview(data)
+        end
+
+        kvs = {}
+        if TraceView::Config[:curb][:cross_host]
+          kvs[:HTTPMethod] = :PUT
+        end
+
+        profile_curb_method(kvs, :http_post_without_traceview, args, &block)
+      end
+
+      ##
+      # perform_with_traceview
+      #
+      # ::Curl::Easy.new.perform wrapper
+      #
+      def perform_with_traceview(&block)
+        # If we're not tracing, just do a fast return.
+        if !TraceView.tracing? || TraceView.tracing_layer?('curb')
+          return perform_without_traceview(&block)
+        end
+
+        kvs = {}
+        # This perform gets called from two places, ::Curl::Easy.new.perform
+        # and Curl::Easy.new.http_head. In the case of http_head we detect the
+        # HTTP verb via get info.
+        if TraceView::Config[:curb][:cross_host]
+          if self.getinfo(self.sym2curl(:nobody))
+            kvs[:HTTPMethod] = :HEAD
+          else
+            kvs[:HTTPMethod] = :GET
+          end
+        end
+
+        return profile_curb_method(kvs, :perform_without_traceview, nil, &block)
+      end
+
+      ##
+      # http_with_traceview
+      #
+      # ::Curl::Easy.new.http wrapper
+      #
+      def http_with_traceview(verb, &block)
+        # If we're not tracing, just do a fast return.
+        return http_without_traceview(verb) if !TraceView.tracing?
+
+        kvs = {}
+        if TraceView::Config[:curb][:cross_host]
+          kvs[:HTTPMethod] = verb
+        end
+
+        profile_curb_method(kvs, :http_without_traceview, [verb], &block)
+      end
+    end
+
+    ##
+    # CurlMultiCM
+    #
+    # This module contains the class method wrappers for the CurlMulti class.
+    # This module should be _extended_ by CurlMulti.
+    #
+    module CurlMultiCM
+      def self.extended(klass)
+        ::TraceView::Util.class_method_alias(klass, :http, ::Curl::Multi)
+      end
+
+      ##
+      # http_with_traceview
+      #
+      # ::Curl::Multi.new.http wrapper
+      #
+      def http_with_traceview(urls_with_config, multi_options={}, &block)
+        # If we're not tracing, just do a fast return.
+        if !TraceView.tracing?
+          return http_without_traceview(urls_with_config, multi_options, &block)
+        end
+
+        begin
+          kvs = {}
+          kvs['Backtrace'] = TraceView::API.backtrace if TraceView::Config[:curb][:collect_backtraces]
+
+          TraceView::API.log_entry('curb_multi', kvs)
+
+          # The core curb call
+          http_without_traceview(urls_with_config, multi_options, &block)
+        rescue => e
+          TraceView::API.log_exception('curb_multi', e)
+          raise e
+        ensure
+          TraceView::API.log_exit('curb_multi')
+        end
+      end
+    end
+
+    ##
+    # CurlMultiIM
+    #
+    # This module contains the instance method wrappers for the CurlMulti class.
+    # This module should be _included_ into CurlMulti.
+    #
+    module CurlMultiIM
+      def self.included(klass)
+        ::TraceView::Util.method_alias(klass, :perform, ::Curl::Multi)
+      end
+
+      ##
+      # perform_with_traceview
+      #
+      # ::Curl::Multi.new.perform wrapper
+      #
+      def perform_with_traceview(&block)
+        # If we're not tracing or we're not already tracing curb, just do a fast return.
+        if !TraceView.tracing? || ['curb', 'curb_multi'].include?(TraceView.layer)
+          return perform_without_traceview(&block)
+        end
+
+        begin
+          kvs = {}
+          kvs['Backtrace'] = TraceView::API.backtrace if TraceView::Config[:curb][:collect_backtraces]
+
+          TraceView::API.log_entry('curb_multi', kvs)
+
+          # The core curb call
+          perform_without_traceview(&block)
+        rescue => e
+          TraceView::API.log_exception('curb_multi', e)
+          raise e
+        ensure
+          TraceView::API.log_exit('curb_multi')
+        end
+      end
+    end
+  end
+end
+
+if TraceView::Config[:curb][:enabled] && defined?(::Curl) && RUBY_VERSION > '1.8.7'
+  ::TraceView.logger.info '[traceview/loading] Instrumenting curb' if TraceView::Config[:verbose]
+  ::TraceView::Util.send_include(::Curl::Easy, ::TraceView::Inst::CurlEasy)
+  ::TraceView::Util.send_extend(::Curl::Multi, ::TraceView::Inst::CurlMultiCM)
+  ::TraceView::Util.send_include(::Curl::Multi, ::TraceView::Inst::CurlMultiIM)
+end

data/lib/traceview/instrumentation.rb

@@ -14,6 +14,7 @@ module TraceView
           require f
         rescue => e
           TraceView.logger.error "[traceview/loading] Error loading instrumentation file '#{f}' : #{e}"
+          TraceView.logger.debug "[traceview/loading] #{e.backtrace.first}"
         end
       end
     end

data/lib/traceview/util.rb

@@ -205,6 +205,7 @@ module TraceView
 
           # Report the instrumented libraries
           platform_info['Ruby.Cassandra.Version']  = "Cassandra-#{::Cassandra.VERSION}"    if defined?(::Cassandra.VERSION)
+          platform_info['Ruby.Curb.Version']       = "Curb-#{::Curl::VERSION}"             if defined?(::Curl::VERSION)
           platform_info['Ruby.Dalli.Version']      = "Dalli-#{::Dalli::VERSION}"           if defined?(::Dalli::VERSION)
           platform_info['Ruby.Excon.Version']      = "Excon-#{::Excon::VERSION}"           if defined?(::Excon::VERSION)
           platform_info['Ruby.Faraday.Version']    = "Faraday-#{::Faraday::VERSION}"       if defined?(::Faraday::VERSION)

data/lib/traceview/version.rb

@@ -7,8 +7,8 @@ module TraceView
   # traceview.gemspec during gem build process
   module Version
     MAJOR = 3
-    MINOR = 0
-    PATCH = 5
+    MINOR = 1
+    PATCH = 0
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

data/test/instrumentation/curb_test.rb

@@ -0,0 +1,542 @@
+# Copyright (c) 2015 AppNeta, Inc.
+# All rights reserved.
+
+if RUBY_VERSION > '1.8.7'
+
+  require 'minitest_helper'
+  require 'traceview/inst/rack'
+  require File.expand_path(File.dirname(__FILE__) + '../../frameworks/apps/sinatra_simple')
+
+  class CurbTest < Minitest::Test
+    include Rack::Test::Methods
+
+    def setup
+      clear_all_traces
+      TraceView.config_lock.synchronize {
+        @cb = TraceView::Config[:curb][:collect_backtraces]
+        @log_args = TraceView::Config[:curb][:log_args]
+        @tm = TraceView::Config[:tracing_mode]
+        @cross_host = TraceView::Config[:curb][:cross_host]
+      }
+    end
+
+    def teardown
+      TraceView.config_lock.synchronize {
+        TraceView::Config[:curb][:collect_backtraces] = @cb
+        TraceView::Config[:curb][:log_args] = @log_args
+        TraceView::Config[:tracing_mode] = @tm
+        TraceView::Config[:curb][:cross_host] = @cross_host
+      }
+    end
+
+    def app
+      SinatraSimple
+    end
+
+    def test_reports_version_init
+      init_kvs = ::TraceView::Util.build_init_report
+      assert init_kvs.key?('Ruby.Curb.Version')
+      assert_equal init_kvs['Ruby.Curb.Version'], "Curb-#{::Curl::VERSION}"
+    end
+
+    def test_class_get_request
+      response = nil
+
+      TraceView::API.start_trace('curb_tests') do
+        response = Curl.get('http://127.0.0.1:8101/')
+      end
+
+      assert response.body_str == "Hello TraceView!"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+    end
+
+    def test_class_delete_request
+      response = nil
+
+      TraceView::API.start_trace('curb_tests') do
+        response = Curl.delete('http://127.0.0.1:8101/?curb_delete_test', :id => 1)
+      end
+
+      assert response.body_str == "Hello TraceView!"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+    end
+
+    def test_class_post_request
+      response = nil
+
+      TraceView::API.start_trace('curb_tests') do
+        response = Curl.post('http://127.0.0.1:8101/')
+      end
+
+      assert response.body_str == "Hello TraceView!"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+    end
+
+    def test_easy_class_perform
+      response = nil
+
+      TraceView::API.start_trace('curb_tests') do
+        response = Curl::Easy.perform("http://127.0.0.1:8101/")
+      end
+
+      assert response.is_a?(::Curl::Easy)
+      assert response.body_str == "Hello TraceView!"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7,                         traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+    end
+
+    def test_easy_http_head
+      c = nil
+
+      TraceView::API.start_trace('curb_tests') do
+        c = Curl::Easy.new("http://127.0.0.1:8101/")
+        c.http_head
+      end
+
+      assert c.is_a?(::Curl::Easy), "Response type"
+      assert c.response_code == 200
+      assert c.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+    end
+
+    def test_easy_http_put
+      c = nil
+
+      TraceView::API.start_trace('curb_tests') do
+        c = Curl::Easy.new("http://127.0.0.1:8101/")
+        c.http_put(:id => 1)
+      end
+
+      assert c.is_a?(::Curl::Easy), "Response type"
+      assert c.response_code == 200
+      assert c.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+    end
+
+    def test_easy_http_post
+      c = nil
+
+      TraceView::API.start_trace('curb_tests') do
+        url = "http://127.0.0.1:8101/"
+        c = Curl::Easy.new(url)
+        c.http_post(url, :id => 1)
+      end
+
+      assert c.is_a?(::Curl::Easy), "Response type"
+      assert c.response_code == 200
+      assert c.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+    end
+
+    def test_class_fetch_with_block
+      response = nil
+
+      TraceView::API.start_trace('curb_tests') do
+        response = Curl::Easy.perform("http://127.0.0.1:8101/") do |curl|
+          curl.headers["User-Agent"] = "TraceView 2000"
+        end
+      end
+
+      assert response.is_a?(::Curl::Easy), "Response type"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal traces[5]['Label'], 'exit'
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+      assert_equal false,                     traces[5].key?('HTTPStatus')
+    end
+
+    def test_cross_app_tracing
+      response = nil
+
+      # When testing global config options, use the config_locak
+      # semaphore to lock between other running tests.
+      TraceView.config_lock.synchronize {
+        TraceView::Config[:curb][:cross_host] = true
+
+        TraceView::API.start_trace('curb_tests') do
+          response = ::Curl.get('http://127.0.0.1:8101/?curb_cross_host=1')
+        end
+      }
+
+      xtrace = response.headers['X-Trace']
+      assert xtrace, "X-Trace response header"
+      assert TraceView::XTrace.valid?(xtrace)
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+      assert valid_edges?(traces), "Trace edge validation"
+
+      assert_equal 'curb',                    traces[1]['Layer']
+      assert_equal 'entry',                   traces[1]['Label']
+      assert_equal 1,                         traces[1]['IsService']
+      assert_equal 'GET',                     traces[1]['HTTPMethod'], "HTTP Method"
+      assert_equal "http://127.0.0.1:8101/?curb_cross_host=1&",  traces[1]['RemoteURL']
+      assert       traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+      assert_equal 200,                       traces[5]['HTTPStatus']
+
+    end
+
+    def test_multi_basic_get
+      responses = nil
+      easy_options = {:follow_location => true}
+      multi_options = {:pipeline => false}
+
+      urls = []
+      urls << "http://127.0.0.1:8101/?one=1"
+      urls << "http://127.0.0.1:8101/?two=2"
+      urls << "http://127.0.0.1:8101/?three=3"
+
+      TraceView::API.start_trace('curb_tests') do
+        responses = Curl::Multi.get(urls, easy_options, multi_options) do |easy|
+          nil
+        end
+      end
+
+      traces = get_all_traces
+      assert_equal 13, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal traces[1]['Layer'], 'curb_multi'
+      assert_equal traces[1]['Label'], 'entry'
+      assert_equal traces[11]['Layer'], 'curb_multi'
+      assert_equal traces[11]['Label'], 'exit'
+    end
+
+    def test_multi_basic_post
+      responses = nil
+      easy_options = {:follow_location => true, :multipart_form_post => true}
+      multi_options = {:pipeline => true}
+
+      urls = []
+      urls << { :url => "http://127.0.0.1:8101/1", :post_fields => { :id => 1 } }
+      urls << { :url => "http://127.0.0.1:8101/2", :post_fields => { :id => 2 } }
+      urls << { :url => "http://127.0.0.1:8101/3", :post_fields => { :id => 3 } }
+
+      TraceView::API.start_trace('curb_tests') do
+        responses = Curl::Multi.post(urls, easy_options, multi_options) do |easy|
+          nil
+        end
+      end
+
+      traces = get_all_traces
+      assert_equal 13, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal traces[1]['Layer'], 'curb_multi'
+      assert_equal traces[1]['Label'], 'entry'
+      assert_equal traces[11]['Layer'], 'curb_multi'
+      assert_equal traces[11]['Label'], 'exit'
+    end
+
+    def test_multi_basic_get_pipeline
+      responses = nil
+      easy_options = {:follow_location => true}
+      multi_options = {:pipeline => true}
+
+      urls = []
+      urls << "http://127.0.0.1:8101/?one=1"
+      urls << "http://127.0.0.1:8101/?two=2"
+      urls << "http://127.0.0.1:8101/?three=3"
+
+      TraceView::API.start_trace('curb_tests') do
+        responses = Curl::Multi.get(urls, easy_options, multi_options) do |easy|
+          nil
+        end
+      end
+
+      traces = get_all_traces
+      assert_equal 13, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal traces[1]['Layer'], 'curb_multi'
+      assert_equal traces[1]['Label'], 'entry'
+      assert_equal traces[11]['Layer'], 'curb_multi'
+      assert_equal traces[11]['Label'], 'exit'
+    end
+
+    def test_multi_advanced_get
+      responses = {}
+
+      urls = []
+      urls << "http://127.0.0.1:8101/?one=1"
+      urls << "http://127.0.0.1:8101/?two=2"
+      urls << "http://127.0.0.1:8101/?three=3"
+
+      TraceView::API.start_trace('curb_tests') do
+        m = Curl::Multi.new
+        urls.each do |url|
+          responses[url] = ""
+          c = Curl::Easy.new(url) do |curl|
+            curl.follow_location = true
+          end
+          m.add c
+        end
+
+        m.perform do
+          nil
+        end
+      end
+
+      traces = get_all_traces
+      assert_equal 13, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+
+      assert_equal traces[1]['Layer'], 'curb_multi'
+      assert_equal traces[1]['Label'], 'entry'
+      assert_equal traces[11]['Layer'], 'curb_multi'
+      assert_equal traces[11]['Label'], 'exit'
+    end
+
+    def test_requests_with_errors
+      begin
+        TraceView::API.start_trace('curb_tests') do
+          Curl.get('http://asfjalkfjlajfljkaljf/')
+        end
+      rescue
+      end
+
+      traces = get_all_traces
+      assert_equal 5, traces.count, "Trace count"
+      validate_outer_layers(traces, "curb_tests")
+      assert valid_edges?(traces), "Trace edge validation"
+
+      assert_equal false,                     traces[1].key?('IsService')
+      assert_equal false,                     traces[1].key?('RemoteURL')
+      assert_equal false,                     traces[1].key?('HTTPMethod')
+      assert traces[1].key?('Backtrace')
+
+      assert_equal 'curb',                           traces[2]['Layer']
+      assert_equal 'error',                          traces[2]['Label']
+      assert_equal "Curl::Err::HostResolutionError", traces[2]['ErrorClass']
+      assert traces[2].key?('ErrorMsg')
+      assert traces[2].key?('Backtrace')
+
+      assert_equal 'curb',                           traces[3]['Layer']
+      assert_equal 'exit',                           traces[3]['Label']
+    end
+
+    def test_obey_log_args_when_false
+      # When testing global config options, use the config_locak
+      # semaphore to lock between other running tests.
+      TraceView.config_lock.synchronize {
+        TraceView::Config[:curb][:log_args] = false
+        TraceView::Config[:curb][:cross_host] = true
+
+        http = nil
+
+        TraceView::API.start_trace('curb_tests') do
+          http = Curl.get('http://127.0.0.1:8101/?blah=1')
+        end
+      }
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      assert_equal "http://127.0.0.1:8101/",         traces[1]['RemoteURL']
+    end
+
+    def test_obey_log_args_when_true
+      # When testing global config options, use the config_locak
+      # semaphore to lock between other running tests.
+      TraceView.config_lock.synchronize {
+        TraceView::Config[:curb][:log_args] = true
+        TraceView::Config[:curb][:cross_host] = true
+
+        http = nil
+
+        TraceView::API.start_trace('curb_tests') do
+          http = ::Curl.get('http://127.0.0.1:8101/?blah=1')
+        end
+      }
+
+      traces = get_all_traces
+      assert_equal 7, traces.count, "Trace count"
+      assert_equal "http://127.0.0.1:8101/?blah=1&", traces[1]['RemoteURL']
+    end
+
+    def test_without_tracing_class_get
+      TraceView::Config[:tracing_mode] = :never
+
+      response = nil
+
+      TraceView::API.start_trace('httpclient_tests') do
+        response = ::Curl.get('http://127.0.0.1:8101/?blah=1')
+      end
+
+      assert response.headers['X-Trace'] == nil
+      assert response.body_str == "Hello TraceView!"
+      assert response.response_code == 200
+
+      traces = get_all_traces
+      assert_equal 0, traces.count, "Trace count"
+    end
+
+    def test_without_tracing_easy_perform
+      response = nil
+
+      # When testing global config options, use the config_locak
+      # semaphore to lock between other running tests.
+      TraceView.config_lock.synchronize {
+        TraceView::Config[:tracing_mode] = :never
+
+        TraceView::API.start_trace('curb_tests') do
+          response = Curl::Easy.perform("http://127.0.0.1:8101/")
+        end
+      }
+
+      assert response.headers['X-Trace'] == nil
+      assert response.body_str == "Hello TraceView!"
+      assert response.response_code == 200
+
+      traces = get_all_traces
+      assert_equal 0, traces.count, "Trace count"
+    end
+
+    def test_obey_collect_backtraces_when_true
+      # When testing global config options, use the config_locak
+      # semaphore to lock between other running tests.
+      TraceView.config_lock.synchronize {
+        TraceView::Config[:curb][:collect_backtraces] = true
+        sleep 1
+
+        TraceView::API.start_trace('curb_test') do
+          Curl.get("http://127.0.0.1:8101/")
+        end
+      }
+
+      traces = get_all_traces
+      layer_has_key(traces, 'curb', 'Backtrace')
+    end
+
+    def test_obey_collect_backtraces_when_false
+      # When testing global config options, use the config_locak
+      # semaphore to lock between other running tests.
+      TraceView.config_lock.synchronize {
+        TraceView::Config[:curb][:collect_backtraces] = false
+
+        TraceView::API.start_trace('curb_test') do
+          Curl.get("http://127.0.0.1:8101/")
+        end
+      }
+
+      traces = get_all_traces
+      layer_doesnt_have_key(traces, 'curb', 'Backtrace')
+    end
+  end
+end
+

data/test/support/config_test.rb

@@ -30,12 +30,13 @@ describe "TraceView::Config" do
     instrumentation = TraceView::Config.instrumentation
 
     # Verify the number of individual instrumentations
-    instrumentation.count.must_equal 21
+    instrumentation.count.must_equal 22
 
     TraceView::Config[:action_controller][:enabled].must_equal true
     TraceView::Config[:action_view][:enabled].must_equal true
     TraceView::Config[:active_record][:enabled].must_equal true
     TraceView::Config[:cassandra][:enabled].must_equal true
+    TraceView::Config[:curb][:enabled].must_equal true
     TraceView::Config[:dalli][:enabled].must_equal true
     TraceView::Config[:em_http_request][:enabled].must_equal false
     TraceView::Config[:excon][:enabled].must_equal true
@@ -58,6 +59,7 @@ describe "TraceView::Config" do
     TraceView::Config[:action_view][:log_args].must_equal true
     TraceView::Config[:active_record][:log_args].must_equal true
     TraceView::Config[:cassandra][:log_args].must_equal true
+    TraceView::Config[:curb][:log_args].must_equal true
     TraceView::Config[:dalli][:log_args].must_equal true
     TraceView::Config[:em_http_request][:log_args].must_equal true
     TraceView::Config[:excon][:log_args].must_equal true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: traceview
 version: !ruby/object:Gem::Version
-  version: 3.0.5
+  version: 3.1.0
 platform: java
 authors:
 - Peter Giacomo Lombardo
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-07-20 00:00:00.000000000 Z
+date: 2015-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -119,6 +119,7 @@ files:
 - lib/traceview/frameworks/rails/inst/connection_adapters/utils.rb
 - lib/traceview/frameworks/sinatra.rb
 - lib/traceview/frameworks/sinatra/templates.rb
+- lib/traceview/inst/curb.rb
 - lib/traceview/inst/dalli.rb
 - lib/traceview/inst/em-http-request.rb
 - lib/traceview/inst/excon.rb
@@ -156,6 +157,7 @@ files:
 - test/frameworks/rails4x_test.rb
 - test/frameworks/sinatra_test.rb
 - test/instrumentation/cassandra_test.rb
+- test/instrumentation/curb_test.rb
 - test/instrumentation/dalli_test.rb
 - test/instrumentation/em_http_request_test.rb
 - test/instrumentation/excon_test.rb
@@ -213,7 +215,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.4.5
+rubygems_version: 2.4.8
 signing_key:
 specification_version: 4
 summary: AppNeta TraceView performance instrumentation gem for Ruby
@@ -244,6 +246,7 @@ test_files:
 - test/instrumentation/redis_hashes_test.rb
 - test/instrumentation/mongo_test.rb
 - test/instrumentation/redis_lists_test.rb
+- test/instrumentation/curb_test.rb
 - test/instrumentation/memcached_test.rb
 - test/instrumentation/em_http_request_test.rb
 - test/instrumentation/rest-client_test.rb