instana 1.11.3 → 1.11.8

data/lib/instana/test.rb

@@ -7,14 +7,15 @@ module Instana
       def setup_environment
         # Set defaults if not set
         ENV['MEMCACHED_HOST']     ||= '127.0.0.1:11211'
-        ENV['TRAVIS_PSQL_HOST']   ||= "127.0.0.1"
-        ENV['TRAVIS_PSQL_USER']   ||= "postgres"
+        ENV['POSTGRES_HOST']      ||= "127.0.0.1"
+        ENV['POSTGRES_USER']      ||= "stan"
+        ENV['POSTGRES_PASSWORD']  ||= "stanlikesdata"
         ENV['TRAVIS_MYSQL_HOST']  ||= "127.0.0.1"
         ENV['TRAVIS_MYSQL_USER']  ||= "root"
 
         if !ENV.key?('DATABASE_URL')
           if ENV['DB_FLAVOR'] == 'postgresql'
-            ENV['DATABASE_URL'] = "postgresql://#{ENV['TRAVIS_PSQL_USER']}:#{ENV['TRAVIS_PSQL_PASS']}@#{ENV['TRAVIS_PSQL_HOST']}:5432/travis_ci_test"
+            ENV['DATABASE_URL'] = "postgresql://#{ENV['POSTGRES_USER']}:#{ENV['POSTGRES_PASSWORD']}@#{ENV['POSTGRES_HOST']}:5432/#{ENV['POSTGRES_USER']}"
           elsif ENV['DB_FLAVOR'] == 'mysql'
             ENV['DATABASE_URL'] = "mysql://#{ENV['TRAVIS_MYSQL_USER']}:#{ENV['TRAVIS_MYSQL_PASS']}@#{ENV['TRAVIS_MYSQL_HOST']}:3306/travis_ci_test"
           else

data/lib/instana/tracer.rb

@@ -26,7 +26,7 @@ module Instana
     # Will start a new trace or continue an on-going one (such as
     # from incoming remote requests with context headers).
     #
-    # @param name [String] the name of the span to start
+    # @param name [String, Symbol] the name of the span to start
     # @param kvs [Hash] list of key values to be reported in the span
     # @param incoming_context [Hash] specifies the incoming context.  At a
     #   minimum, it should specify :trace_id and :span_id from the following:
@@ -52,7 +52,7 @@ module Instana
     #   @db.select(1)
     # end
     #
-    # @param name [String] the name of the span to start
+    # @param name [String, Symbol] the name of the span to start
     # @param kvs [Hash] list of key values to be reported in this new span
     #
     def trace(name, kvs = {}, &block)
@@ -72,7 +72,7 @@ module Instana
     # Will start a new trace or continue an on-going one (such as
     # from incoming remote requests with context headers).
     #
-    # @param name [String] the name of the span to start
+    # @param name [String, Symbol] the name of the span to start
     # @param kvs [Hash] list of key values to be reported in the span
     # @param incoming_context [SpanContext or Hash] specifies the incoming context.  At a
     #   minimum, it should specify :trace_id and :span_id from the following:
@@ -107,7 +107,7 @@ module Instana
     # Will establish a new span as a child of the current span
     # in an existing trace
     #
-    # @param name [String] the name of the span to create
+    # @param name [String, Symbol] the name of the span to create
     # @param kvs [Hash] list of key values to be reported in the span
     #
     def log_entry(name, kvs = nil, start_time = ::Instana::Util.now_in_ms, child_of = nil)
@@ -145,7 +145,7 @@ module Instana
     # @note `name` isn't really required but helps keep sanity that
     # we're closing out the span that we really want to close out.
     #
-    # @param name [String] the name of the span to exit (close out)
+    # @param name [String, Symbol] the name of the span to exit (close out)
     # @param kvs [Hash] list of key values to be reported in the span
     #
     def log_exit(name, kvs = {})
@@ -263,6 +263,27 @@ module Instana
       new_span
     end
 
+    # Start a new span which is the child of the current span
+    #
+    # @param operation_name [String] The name of the operation represented by the span
+    # @param child_of [Span] A span to be used as the ChildOf reference
+    # @param start_time [Time] the start time of the span
+    # @param tags [Hash] Starting tags for the span
+    #
+    # @return [Span]
+    #
+    def start_active_span(operation_name, child_of: self.current_span, start_time: ::Instana::Util.now_in_ms, tags: nil)
+      self.current_span = start_span(operation_name, child_of: child_of, start_time: start_time, tags: tags)
+    end
+
+    # Returns the currently active span
+    #
+    # @return [Span]
+    #
+    def active_span
+      self.current_span
+    end
+
     # Inject a span into the given carrier
     #
     # @param span_context [SpanContext]

data/lib/instana/tracing/span.rb

@@ -303,6 +303,15 @@ module Instana
     # a String, Numeric, or Boolean it will be encoded with to_s
     #
     def set_tag(key, value)
+      if ![Symbol, String].include?(key.class)
+        key = key.to_s
+      end
+
+      # If <value> is not a Symbol, String, Array, Hash or Numeric - convert to string
+      if ![Symbol, String, Array, TrueClass, FalseClass, Hash].include?(value.class) && !value.is_a?(Numeric)
+        value = value.to_s
+      end
+
       if custom?
         @data[:data][:sdk][:custom] ||= {}
         @data[:data][:sdk][:custom][:tags] ||= {}

data/lib/instana/util.rb

@@ -176,10 +176,14 @@ module Instana
         end
 
         if defined?(::Resque)
+          # Just because Resque is defined doesn't mean this is a resque process necessarily
+          # Check arguments for a match
           if ($0 =~ /resque-#{Resque::Version}/)
             return "Resque Worker"
           elsif ($0 =~ /resque-pool-master/)
             return "Resque Pool Master"
+          elsif ($0 =~ /resque-scheduler/)
+            return "Resque Scheduler"
           end
         end
 
@@ -187,10 +191,20 @@ module Instana
           return Rails.application.class.to_s.split('::')[0]
         end
 
-        return File.basename($0)
+        if $0.to_s.empty?
+          return "Ruby"
+        end
+
+        exe = File.basename($0)
+        if exe == "rake"
+          return "Rake"
+        end
+
+        return exe
       rescue Exception => e
         Instana.logger.info "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}"
         Instana.logger.debug { e.backtrace.join("\r\n") }
+        return "Ruby"
       end
 
       # Get the current time in milliseconds from the epoch

data/lib/instana/version.rb

@@ -1,4 +1,4 @@
 module Instana
-  VERSION = "1.11.3"
+  VERSION = "1.11.8"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/test/frameworks/rack_test.rb

@@ -29,23 +29,33 @@ class RackTest < Minitest::Test
     # Span validation
     assert_equal 1, spans.count
 
-    first_span = spans.first
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:http)
-    assert_equal "GET", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert_equal 'example.org', first_span[:data][:http][:host]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+
+    assert last_response.headers.key?("X-Instana-T")
+    assert last_response.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+    assert last_response.headers.key?("X-Instana-S")
+    assert last_response.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+    assert last_response.headers.key?("X-Instana-L")
+    assert last_response.headers["X-Instana-L"] == '1'
+    assert last_response.headers.key?("Server-Timing")
+    assert last_response.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+
+    assert rack_span.key?(:data)
+    assert rack_span[:data].key?(:http)
+    assert_equal "GET", rack_span[:data][:http][:method]
+    assert_equal "/mrlobster", rack_span[:data][:http][:url]
+    assert_equal 200, rack_span[:data][:http][:status]
+    assert_equal 'example.org', rack_span[:data][:http][:host]
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
 
     # Backtrace fingerprint validation
-    assert first_span.key?(:stack)
-    assert_equal 2, first_span[:stack].count
-    refute_nil first_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
+    assert rack_span.key?(:stack)
+    assert_equal 2, rack_span[:stack].count
+    refute_nil rack_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
 
     # Restore to default
     ::Instana.config[:collect_backtraces] = false
@@ -63,8 +73,8 @@ class RackTest < Minitest::Test
     # Span validation
     assert_equal 1, spans.count
 
-    first_span = spans.first
-    assert_equal 'WalterBishop', first_span[:data][:service]
+    rack_span = spans.first
+    assert_equal 'WalterBishop', rack_span[:data][:service]
 
     ENV.delete('INSTANA_SERVICE_NAME')
   end
@@ -78,17 +88,27 @@ class RackTest < Minitest::Test
 
     # Span validation
     assert_equal 1, spans.count
-    first_span = spans.first
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:http)
-    assert_equal "POST", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+
+    assert last_response.headers.key?("X-Instana-T")
+    assert last_response.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+    assert last_response.headers.key?("X-Instana-S")
+    assert last_response.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+    assert last_response.headers.key?("X-Instana-L")
+    assert last_response.headers["X-Instana-L"] == '1'
+    assert last_response.headers.key?("Server-Timing")
+    assert last_response.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+
+    assert rack_span.key?(:data)
+    assert rack_span[:data].key?(:http)
+    assert_equal "POST", rack_span[:data][:http][:method]
+    assert_equal "/mrlobster", rack_span[:data][:http][:url]
+    assert_equal 200, rack_span[:data][:http][:status]
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
   end
 
   def test_basic_put
@@ -100,17 +120,27 @@ class RackTest < Minitest::Test
 
     # Span validation
     assert_equal 1, spans.count
-    first_span = spans.first
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:http)
-    assert_equal "PUT", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+
+    assert last_response.headers.key?("X-Instana-T")
+    assert last_response.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+    assert last_response.headers.key?("X-Instana-S")
+    assert last_response.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+    assert last_response.headers.key?("X-Instana-L")
+    assert last_response.headers["X-Instana-L"] == '1'
+    assert last_response.headers.key?("Server-Timing")
+    assert last_response.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+
+    assert rack_span.key?(:data)
+    assert rack_span[:data].key?(:http)
+    assert_equal "PUT", rack_span[:data][:http][:method]
+    assert_equal "/mrlobster", rack_span[:data][:http][:url]
+    assert_equal 200, rack_span[:data][:http][:status]
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
   end
 
   def test_context_continuation
@@ -125,23 +155,33 @@ class RackTest < Minitest::Test
 
     # Span validation
     assert_equal 1, spans.count
-    first_span = spans.first
-    assert_equal :rack, first_span[:n]
-    assert first_span.key?(:data)
-    assert first_span[:data].key?(:http)
-    assert_equal "GET", first_span[:data][:http][:method]
-    assert_equal "/mrlobster", first_span[:data][:http][:url]
-    assert_equal 200, first_span[:data][:http][:status]
-    assert first_span.key?(:f)
-    assert first_span[:f].key?(:e)
-    assert first_span[:f].key?(:h)
-    assert_equal ::Instana.agent.agent_uuid, first_span[:f][:h]
+    rack_span = spans.first
+    assert_equal :rack, rack_span[:n]
+
+    assert last_response.headers.key?("X-Instana-T")
+    assert last_response.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+    assert last_response.headers.key?("X-Instana-S")
+    assert last_response.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+    assert last_response.headers.key?("X-Instana-L")
+    assert last_response.headers["X-Instana-L"] == '1'
+    assert last_response.headers.key?("Server-Timing")
+    assert last_response.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+
+    assert rack_span.key?(:data)
+    assert rack_span[:data].key?(:http)
+    assert_equal "GET", rack_span[:data][:http][:method]
+    assert_equal "/mrlobster", rack_span[:data][:http][:url]
+    assert_equal 200, rack_span[:data][:http][:status]
+    assert rack_span.key?(:f)
+    assert rack_span[:f].key?(:e)
+    assert rack_span[:f].key?(:h)
+    assert_equal ::Instana.agent.agent_uuid, rack_span[:f][:h]
 
     # Context validation
     # The first span should have the passed in trace ID
     # and specify the passed in span ID as it's parent.
-    assert_equal 1234, first_span[:t]
-    assert_equal 4321, first_span[:p]
+    assert_equal 1234, rack_span[:t]
+    assert_equal 4321, rack_span[:p]
   end
 
   def test_instana_response_headers
@@ -181,17 +221,17 @@ class RackTest < Minitest::Test
 
     # Span validation
     assert_equal 1, spans.count
-    first_span = spans.first
+    rack_span = spans.first
 
-    assert first_span[:data][:http].key?(:header)
-    assert first_span[:data][:http][:header].key?(:"X-Capture-This")
-    assert !first_span[:data][:http][:header].key?(:"X-Capture-That")
-    assert_equal "ThereYouGo", first_span[:data][:http][:header][:"X-Capture-This"]
+    assert rack_span[:data][:http].key?(:header)
+    assert rack_span[:data][:http][:header].key?(:"X-Capture-This")
+    assert !rack_span[:data][:http][:header].key?(:"X-Capture-That")
+    assert_equal "ThereYouGo", rack_span[:data][:http][:header][:"X-Capture-This"]
 
     # Backtrace fingerprint validation
-    assert first_span.key?(:stack)
-    assert_equal 2, first_span[:stack].count
-    refute_nil first_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
+    assert rack_span.key?(:stack)
+    assert_equal 2, rack_span[:stack].count
+    refute_nil rack_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
 
     # Restore to default
     ::Instana.config[:collect_backtraces] = false

data/test/frameworks/rails/actionview5_test.rb

@@ -190,7 +190,7 @@ class ActionViewTest < Minitest::Test
     assert_equal :partial, fourth_span[:data][:render][:type]
     assert_equal 'syntax_error', fourth_span[:data][:render][:name]
     assert fourth_span[:data][:log].key?(:message)
-    assert_equal "SyntaxError", fourth_span[:data][:log][:parameters]
+    assert(fourth_span[:data][:log][:parameters].include?("SyntaxError"))
     assert fourth_span[:error]
     assert fourth_span[:stack]
   end

data/test/frameworks/sinatra_test.rb

@@ -1,4 +1,4 @@
-
+require 'sinatra'
 if defined?(::Sinatra)
   require 'test_helper'
   require File.expand_path(File.dirname(__FILE__) + '/../apps/sinatra')
@@ -17,28 +17,36 @@ if defined?(::Sinatra)
       r = get '/'
       assert last_response.ok?
 
-      assert r.headers.key?("X-Instana-T")
-      assert r.headers.key?("X-Instana-S")
 
       spans = ::Instana.processor.queued_spans
       assert_equal 1, spans.count
 
-      first_span = spans.first
-      assert_equal :rack, first_span[:n]
-      assert first_span.key?(:data)
-      assert first_span[:data].key?(:http)
-
-      assert first_span[:data][:http].key?(:method)
-      assert_equal "GET", first_span[:data][:http][:method]
+      rack_span = spans.first
+      assert_equal :rack, rack_span[:n]
+      # ::Instana::Util.pry!
 
-      assert first_span[:data][:http].key?(:url)
-      assert_equal "/", first_span[:data][:http][:url]
-
-      assert first_span[:data][:http].key?(:status)
-      assert_equal 200, first_span[:data][:http][:status]
-
-      assert first_span[:data][:http].key?(:host)
-      assert_equal "example.org", first_span[:data][:http][:host]
+      assert r.headers.key?("X-Instana-T")
+      assert r.headers["X-Instana-T"] == ::Instana::Util.id_to_header(rack_span[:t])
+      assert r.headers.key?("X-Instana-S")
+      assert r.headers["X-Instana-S"] == ::Instana::Util.id_to_header(rack_span[:s])
+      assert r.headers.key?("X-Instana-L")
+      assert r.headers["X-Instana-L"] == '1'
+      assert r.headers.key?("Server-Timing")
+      assert r.headers["Server-Timing"] == "intid;desc=#{::Instana::Util.id_to_header(rack_span[:t])}"
+      
+      assert rack_span.key?(:data)
+      assert rack_span[:data].key?(:http)
+      assert rack_span[:data][:http].key?(:method)
+      assert_equal "GET", rack_span[:data][:http][:method]
+
+      assert rack_span[:data][:http].key?(:url)
+      assert_equal "/", rack_span[:data][:http][:url]
+
+      assert rack_span[:data][:http].key?(:status)
+      assert_equal 200, rack_span[:data][:http][:status]
+
+      assert rack_span[:data][:http].key?(:host)
+      assert_equal "example.org", rack_span[:data][:http][:host]
     end
   end
 end

data/test/instrumentation/grpc_test.rb

@@ -14,7 +14,7 @@ class GrpcTest < Minitest::Test
 
     if error
       assert_equal true, data[:rpc][:error]
-      assert_equal "2:RuntimeError: #{error}", data[:log][:message]
+      assert data[:log][:message].include?("2:RuntimeError: #{error}")
     end
   end
 

data/test/instrumentation/redis_test.rb

@@ -1,40 +1,44 @@
 require 'test_helper'
 
 class RedisTest < Minitest::Test
+  def setup
+    if ENV.key?('REDIS_URL')
+      @redis_url = ENV['REDIS_URL']
+    else
+      @redis_url = "redis://localhost:6379"
+    end
+    @redis_client = Redis.new(url: @redis_url)
+  end
+
   def test_normal_call
     clear_all!
-    redis_client = create_redis_client
 
     Instana.tracer.start_or_continue_trace(:redis_test) do
-      redis_client.set('hello', 'world')
+      @redis_client.set('hello', 'world')
     end
-    redis_client.disconnect!
 
     assert_redis_trace('SET')
   end
 
   def test_normal_call_with_error
     clear_all!
-    redis_client = create_redis_client
 
     Instana.tracer.start_or_continue_trace(:redis_test) do
       begin
-        redis_client.zadd('hello', 'invalid', 'value')
+        @redis_client.zadd('hello', 'invalid', 'value')
       rescue; end
     end
-    redis_client.disconnect!
 
     assert_redis_trace('ZADD', with_error: 'ERR value is not a valid float')
   end
 
   def test_pipeline_call
     clear_all!
-    redis_client = create_redis_client
 
     Instana.tracer.start_or_continue_trace(:redis_test) do
-      redis_client.pipelined do
-        redis_client.set('hello', 'world')
-        redis_client.set('other', 'world')
+      @redis_client.pipelined do
+        @redis_client.set('hello', 'world')
+        @redis_client.set('other', 'world')
       end
     end
 
@@ -43,13 +47,12 @@ class RedisTest < Minitest::Test
 
   def test_pipeline_call_with_error
     clear_all!
-    redis_client = create_redis_client
 
     Instana.tracer.start_or_continue_trace(:redis_test) do
       begin
-        redis_client.pipelined do
-          redis_client.set('other', 'world')
-          redis_client.call('invalid')
+        @redis_client.pipelined do
+          @redis_client.set('other', 'world')
+          @redis_client.call('invalid')
         end
       rescue; end
     end
@@ -59,12 +62,11 @@ class RedisTest < Minitest::Test
 
   def test_multi_call
     clear_all!
-    redis_client = create_redis_client
 
     Instana.tracer.start_or_continue_trace(:redis_test) do
-      redis_client.multi do
-        redis_client.set('hello', 'world')
-        redis_client.set('other', 'world')
+      @redis_client.multi do
+        @redis_client.set('hello', 'world')
+        @redis_client.set('other', 'world')
       end
     end
 
@@ -73,13 +75,12 @@ class RedisTest < Minitest::Test
 
   def test_multi_call_with_error
     clear_all!
-    redis_client = create_redis_client
 
     Instana.tracer.start_or_continue_trace(:redis_test) do
       begin
-        redis_client.multi do
-          redis_client.set('other', 'world')
-          redis_client.call('invalid')
+        @redis_client.multi do
+          @redis_client.set('other', 'world')
+          @redis_client.call('invalid')
         end
       rescue; end
     end
@@ -89,10 +90,6 @@ class RedisTest < Minitest::Test
 
   private
 
-  def create_redis_client
-    Redis.new(url: ENV['I_REDIS_URL'])
-  end
-
   def assert_redis_trace(command, with_error: nil)
     spans = ::Instana.processor.queued_spans
     assert_equal 2, spans.length
@@ -105,10 +102,10 @@ class RedisTest < Minitest::Test
 
     data = second_span[:data]
 
-    uri = URI.parse(ENV['I_REDIS_URL'])
+    uri = URI.parse(@redis_url)
     assert_equal "#{uri.host}:#{uri.port}", data[:redis][:connection]
 
-    assert_equal 0, data[:redis][:db]
+    assert_equal "0", data[:redis][:db]
     assert_equal command, data[:redis][:command]
 
     if with_error