appoptics_apm 4.0.2

data/test/instrumentation/bunny_consumer_test.rb

@@ -0,0 +1,204 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'minitest_helper'
+
+unless defined?(JRUBY_VERSION)
+  class BunnyConsumerTest < Minitest::Test
+    def setup
+      # Support specific environment variables to support remote rabbitmq servers
+      ENV['APPOPTICS_RABBITMQ_SERVER'] = "127.0.0.1"      unless ENV['APPOPTICS_RABBITMQ_SERVER']
+      ENV['APPOPTICS_RABBITMQ_PORT'] = "5672"             unless ENV['APPOPTICS_RABBITMQ_PORT']
+      ENV['APPOPTICS_RABBITMQ_USERNAME'] = "guest"        unless ENV['APPOPTICS_RABBITMQ_USERNAME']
+      ENV['APPOPTICS_RABBITMQ_PASSWORD'] = "guest"        unless ENV['APPOPTICS_RABBITMQ_PASSWORD']
+      ENV['APPOPTICS_RABBITMQ_VHOST'] = "/"               unless ENV['APPOPTICS_RABBITMQ_VHOST']
+
+      @connection_params = {}
+      @connection_params[:host]   = ENV['APPOPTICS_RABBITMQ_SERVER']
+      @connection_params[:port]   = ENV['APPOPTICS_RABBITMQ_PORT']
+      @connection_params[:vhost]  = ENV['APPOPTICS_RABBITMQ_VHOST']
+      @connection_params[:user]   = ENV['APPOPTICS_RABBITMQ_USERNAME']
+      @connection_params[:pass]   = ENV['APPOPTICS_RABBITMQ_PASSWORD']
+
+      clear_all_traces
+    end
+
+    def test_consume
+      @conn = Bunny.new(@connection_params)
+      @conn.start
+      @ch = @conn.create_channel
+      @queue = @ch.queue("tv.ruby.consumer.test", :exclusive => true)
+      @exchange  = @ch.default_exchange
+
+      @queue.subscribe(:block => false, :manual_ack => true) do |delivery_info, properties, payload|
+        # Make an http call to spice things up
+        uri = URI('http://127.0.0.1:8101/')
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.get('/?q=1').read_body
+      end
+
+      AppOpticsAPM::API.start_trace('bunny_consume_test') do
+        @exchange.publish("The Tortoise and the Hare", :routing_key => @queue.name, :app_id => "msg_app", :type => :generic)
+      end
+
+      sleep 1
+
+      traces = get_all_traces
+
+      traces.count.must_equal 12
+      assert valid_edges?(traces), "Invalid edge in traces"
+
+      traces[5]['Layer'].must_equal "net-http"
+      traces[5]['Label'].must_equal "entry"
+      traces[10]['Layer'].must_equal "net-http"
+      traces[10]['Label'].must_equal "exit"
+
+      traces[4]['Spec'].must_equal "job"
+      traces[4]['Flavor'].must_equal "rabbitmq"
+      traces[4]['Queue'].must_equal "tv.ruby.consumer.test"
+      traces[4]['RemoteHost'].must_equal @connection_params[:host]
+      traces[4]['RemotePort'].must_equal @connection_params[:port].to_i
+      traces[4]['VirtualHost'].must_equal @connection_params[:vhost]
+      traces[4]['RoutingKey'].must_equal "tv.ruby.consumer.test"
+      traces[4]['Controller'].must_equal "msg_app"
+      traces[4]['Action'].must_equal "generic"
+      traces[4]['URL'].must_equal "/bunny/tv.ruby.consumer.test"
+      traces[4].key?('SourceTrace').must_equal true
+      traces[4].key?('Backtrace').must_equal false
+
+      @conn.close
+    end
+
+    def test_blocking_consume
+      skip if RUBY_VERSION < '2.0'
+      @conn = Bunny.new(@connection_params)
+      @conn.start
+      @ch = @conn.create_channel
+      @queue = @ch.queue("tv.ruby.consumer.blocking.test", :exclusive => true)
+      @exchange  = @ch.default_exchange
+
+      Thread.new {
+        @queue.subscribe(:block => true, :manual_ack => true) do |delivery_info, properties, payload|
+          # Make an http call to spice things up
+          uri = URI('http://127.0.0.1:8101/')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.get('/?q=1').read_body
+        end
+      }
+
+      @exchange.publish("The Tortoise and the Hare", :routing_key => @queue.name, :app_id => "msg_app", :type => :generic)
+
+      sleep 1
+
+      traces = get_all_traces
+      traces.count.must_equal 8
+
+      validate_outer_layers(traces, "rabbitmq-consumer")
+      assert valid_edges?(traces), "Invalid edge in traces"
+
+      traces[1]['Layer'].must_equal "net-http"
+      traces[1]['Label'].must_equal "entry"
+      traces[6]['Layer'].must_equal "net-http"
+      traces[6]['Label'].must_equal "exit"
+
+      traces[0]['Spec'].must_equal "job"
+      traces[0]['Flavor'].must_equal "rabbitmq"
+      traces[0]['Queue'].must_equal "tv.ruby.consumer.blocking.test"
+      traces[0]['RemoteHost'].must_equal @connection_params[:host]
+      traces[0]['RemotePort'].must_equal @connection_params[:port].to_i
+      traces[0]['VirtualHost'].must_equal @connection_params[:vhost]
+      traces[0]['RoutingKey'].must_equal "tv.ruby.consumer.blocking.test"
+      traces[0]['Controller'].must_equal "msg_app"
+      traces[0]['Action'].must_equal "generic"
+      traces[0]['URL'].must_equal "/bunny/tv.ruby.consumer.blocking.test"
+      traces[0].key?('Backtrace').must_equal false
+
+      @conn.close
+    end
+
+    def test_consume_error_handling
+      @conn = Bunny.new(@connection_params)
+      @conn.start
+      @ch = @conn.create_channel
+      @queue = @ch.queue("tv.ruby.consumer.error.test", :exclusive => true)
+      @exchange  = @ch.default_exchange
+
+      @queue.subscribe(:block => false, :manual_ack => true) do |delivery_info, properties, payload|
+        raise "blah"
+      end
+
+      @exchange.publish("The Tortoise and the Hare", :routing_key => @queue.name, :app_id => "msg_app", :type => :generic)
+
+      sleep 1
+
+      traces = get_all_traces
+      traces.count.must_equal 3
+
+      validate_outer_layers(traces, "rabbitmq-consumer")
+      assert valid_edges?(traces), "Invalid edge in traces"
+
+      traces[0]['Spec'].must_equal "job"
+      traces[0]['Flavor'].must_equal "rabbitmq"
+      traces[0]['Queue'].must_equal "tv.ruby.consumer.error.test"
+      traces[0]['RemoteHost'].must_equal @connection_params[:host]
+      traces[0]['RemotePort'].must_equal @connection_params[:port].to_i
+      traces[0]['VirtualHost'].must_equal @connection_params[:vhost]
+      traces[0]['RoutingKey'].must_equal "tv.ruby.consumer.error.test"
+      traces[0]['Controller'].must_equal "msg_app"
+      traces[0]['Action'].must_equal "generic"
+      traces[0]['URL'].must_equal "/bunny/tv.ruby.consumer.error.test"
+      traces[0].key?('Backtrace').must_equal false
+
+      traces[1]['Layer'].must_equal "rabbitmq-consumer"
+      traces[1]['Label'].must_equal "error"
+      traces[1]['ErrorClass'].must_equal "RuntimeError"
+      traces[1]['ErrorMsg'].must_equal "blah"
+      traces[1].key?('Backtrace').must_equal true
+
+      traces[2]['Layer'].must_equal "rabbitmq-consumer"
+      traces[2]['Label'].must_equal "exit"
+    end
+
+    def test_message_id_capture
+      @conn = Bunny.new(@connection_params)
+      @conn.start
+      @ch = @conn.create_channel
+      @queue = @ch.queue("tv.ruby.consumer.msgid.test", :exclusive => true)
+      @exchange  = @ch.default_exchange
+
+      @queue.subscribe(:block => false, :manual_ack => true) do |delivery_info, properties, payload|
+        # Make an http call to spice things up
+        uri = URI('http://127.0.0.1:8101/')
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.get('/?q=1').read_body
+      end
+
+      AppOpticsAPM::API.start_trace('bunny_consume_test') do
+        @exchange.publish("The Tortoise and the Hare", :message_id => "1234", :routing_key => @queue.name, :app_id => "msg_app", :type => :generic)
+      end
+
+      sleep 1
+
+      traces = get_all_traces
+
+      traces.count.must_equal 12
+      assert valid_edges?(traces), "Invalid edge in traces"
+
+      traces[4]['Spec'].must_equal "job"
+      traces[4]['Flavor'].must_equal "rabbitmq"
+      traces[4]['Queue'].must_equal "tv.ruby.consumer.msgid.test"
+      traces[4]['RemoteHost'].must_equal @connection_params[:host]
+      traces[4]['RemotePort'].must_equal @connection_params[:port].to_i
+      traces[4]['VirtualHost'].must_equal @connection_params[:vhost]
+      traces[4]['RoutingKey'].must_equal "tv.ruby.consumer.msgid.test"
+      traces[4]['Controller'].must_equal "msg_app"
+      traces[4]['Action'].must_equal "generic"
+      traces[4]['URL'].must_equal "/bunny/tv.ruby.consumer.msgid.test"
+      traces[4]['MsgID'].must_equal "1234"
+      traces[4].key?('SourceTrace').must_equal true
+      traces[4].key?('Backtrace').must_equal false
+
+      @conn.close
+    end
+  end
+end

data/test/instrumentation/curb_test.rb

@@ -0,0 +1,398 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+if RUBY_VERSION > '1.8.7' && !defined?(JRUBY_VERSION)
+
+  require 'minitest_helper'
+  require 'appoptics_apm/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
+      AppOpticsAPM.config_lock.synchronize {
+        @cb = AppOpticsAPM::Config[:curb][:collect_backtraces]
+        @log_args = AppOpticsAPM::Config[:curb][:log_args]
+        @tm = AppOpticsAPM::Config[:tracing_mode]
+      }
+    end
+
+    def teardown
+      AppOpticsAPM.config_lock.synchronize {
+        AppOpticsAPM::Config[:curb][:collect_backtraces] = @cb
+        AppOpticsAPM::Config[:curb][:log_args] = @log_args
+        AppOpticsAPM::Config[:tracing_mode] = @tm
+      }
+    end
+
+    def app
+      SinatraSimple
+    end
+
+    def assert_correct_traces(url, method)
+      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 1,                         traces[1]['IsService']
+      assert_equal url,                      traces[1]['RemoteURL']
+      assert_equal method,                    traces[1]['HTTPMethod']
+      assert                                  traces[1]['Backtrace']
+
+      assert_equal 'curb',                    traces[5]['Layer']
+      assert_equal 'exit',                    traces[5]['Label']
+    end
+
+    def test_reports_version_init
+      init_kvs = ::AppOpticsAPM::Util.build_init_report
+      assert init_kvs.key?('Ruby.curb.Version')
+      assert_equal ::Curl::CURB_VERSION, init_kvs['Ruby.curb.Version']
+    end
+
+    def test_class_get_request
+      response = nil
+
+      AppOpticsAPM::API.start_trace('curb_tests') do
+        response = Curl.get('http://127.0.0.1:8101/')
+      end
+
+      assert response.body_str == "Hello AppOpticsAPM!"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      assert_correct_traces('http://127.0.0.1:8101/', 'GET')
+    end
+
+    def test_class_delete_request
+      response = nil
+
+      AppOpticsAPM::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 AppOpticsAPM!"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      assert_correct_traces('http://127.0.0.1:8101/?curb_delete_test', 'DELETE')
+    end
+
+    def test_class_post_request
+      response = nil
+
+      AppOpticsAPM::API.start_trace('curb_tests') do
+        response = Curl.post('http://127.0.0.1:8101/')
+      end
+
+      assert response.body_str == "Hello AppOpticsAPM!"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      assert_correct_traces('http://127.0.0.1:8101/', 'POST')
+    end
+
+    def test_easy_class_perform
+      response = nil
+
+      AppOpticsAPM::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 AppOpticsAPM!"
+      assert response.response_code == 200
+      assert response.header_str =~ /X-Trace/, "X-Trace response header"
+
+      assert_correct_traces('http://127.0.0.1:8101/', 'GET')
+    end
+
+    def test_easy_http_head
+      c = nil
+
+      AppOpticsAPM::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"
+
+      assert_correct_traces('http://127.0.0.1:8101/', 'GET')
+    end
+
+    def test_easy_http_put
+      c = nil
+
+      AppOpticsAPM::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"
+
+      assert_correct_traces('http://127.0.0.1:8101/', 'PUT')
+    end
+
+    def test_easy_http_post
+      c = nil
+
+      AppOpticsAPM::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"
+
+      assert_correct_traces('http://127.0.0.1:8101/', 'POST')
+    end
+
+    def test_class_fetch_with_block
+      response = nil
+
+      AppOpticsAPM::API.start_trace('curb_tests') do
+        response = Curl::Easy.perform("http://127.0.0.1:8101/") do |curl|
+          curl.headers["User-Agent"] = "AppOpticsAPM 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_correct_traces('http://127.0.0.1:8101/', 'GET')
+    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"
+
+      AppOpticsAPM::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
+      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 } }
+
+      AppOpticsAPM::API.start_trace('curb_tests') do
+        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
+      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"
+
+      AppOpticsAPM::API.start_trace('curb_tests') do
+        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"
+
+      AppOpticsAPM::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
+        AppOpticsAPM::API.start_trace('curb_tests') do
+          Curl.get('http://asfjalkfjlajfljkaljf/')
+        end
+      rescue
+        # ignore exception, only check traces
+      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 1,                                traces[1]['IsService']
+      assert_equal 'http://asfjalkfjlajfljkaljf/',   traces[1]['RemoteURL']
+      assert_equal 'GET',                            traces[1]['HTTPMethod']
+      assert                                         traces[1]['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_lock
+      # semaphore to lock between other running tests.
+      AppOpticsAPM.config_lock.synchronize {
+        AppOpticsAPM::Config[:curb][:log_args] = false
+
+        AppOpticsAPM::API.start_trace('curb_tests') do
+          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_lock
+      # semaphore to lock between other running tests.
+      AppOpticsAPM.config_lock.synchronize {
+        AppOpticsAPM::Config[:curb][:log_args] = true
+
+        AppOpticsAPM::API.start_trace('curb_tests') do
+          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
+      response = ::Curl.get('http://127.0.0.1:8101/?blah=1')
+
+      assert response.headers['X-Trace'] == nil
+      assert response.body_str == "Hello AppOpticsAPM!"
+      assert response.response_code == 200
+    end
+
+    def test_without_tracing_easy_perform
+      response = Curl::Easy.perform("http://127.0.0.1:8101/")
+
+      assert response.headers['X-Trace'] == nil
+      assert response.body_str == "Hello AppOpticsAPM!"
+      assert response.response_code == 200
+    end
+
+    def test_obey_collect_backtraces_when_true
+      # When testing global config options, use the config_lock
+      # semaphore to lock between other running tests.
+      AppOpticsAPM.config_lock.synchronize {
+        AppOpticsAPM::Config[:curb][:collect_backtraces] = true
+        sleep 1
+
+        AppOpticsAPM::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_lock
+      # semaphore to lock between other running tests.
+      AppOpticsAPM.config_lock.synchronize {
+        AppOpticsAPM::Config[:curb][:collect_backtraces] = false
+
+        AppOpticsAPM::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
+