instana 1.13.0 → 1.192.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09630573df5e1941fc17023b97864fd430f6135b9e0a72cd2f19225265b66d16'
-  data.tar.gz: b8dc0dda20938dc03f4ebe0887c3ccd68d03995d07e0c7233a19ff3a0780f1a7
+  metadata.gz: 424f7ce1ff02d56a5498df4f3f861231c30f5032cf02e8604e008155c389f4b5
+  data.tar.gz: aac1bf703a70d5c7039fbae031846d513a5d3d9d2c5d00630308eacd8b862095
 SHA512:
-  metadata.gz: a9bf1d5bfd714b8d1e3e187d0dfe47f0917384fb41b45d8f01b10890c7259c985b20d5adb550d955ac51b8bca9102246e9926ce114d448b391b82e0acdcd46c4
-  data.tar.gz: 139872ad95ceeca46b97be78773d999228ff30563ff90f29e65032bd6b55f7e619fb00a9e130ad6bd06b83dd0bca3e4321428e5172795242c8a045de570bd77a
+  metadata.gz: c9470f7a3f6e1d7198a99d8017556689b0eaffb3bc22677064cbb1f5552f80c8814d481dc842b8a082e5a9c5a6cb86b0f46d95cbbc8055d56c7b2588277bbdaa
+  data.tar.gz: c9e83f799f6b343e6dd98840fcdc48175cc52d9a876c9421e053909bf0dcbfaaf384669b449ce53edf3bd0478ece21484c01c27fd24b6247efcc86ad0a56b0f0

data/gemfiles/libraries.gemfile

@@ -65,6 +65,8 @@ if RUBY_VERSION < '2.2'
   gem 'rack', '< 2.0'
 end
 
+gem 'graphql'
+
 # Include the Instana Ruby gem's base set of gems
 gemspec :path => File.expand_path(File.dirname(__FILE__) + '/../')
 

data/lib/instana/config.rb

@@ -42,12 +42,23 @@ module Instana
       # ::Instana.config[:collect_backtraces] = true
       @config[:collect_backtraces] = false
 
+      # By default, collected SQL will be sanitized to remove potentially sensitive bind params such as:
+      #   > SELECT  "blocks".* FROM "blocks"  WHERE "blocks"."name" = "Mr. Smith"
+      #
+      # ...would be sanitized to be:
+      #   > SELECT  "blocks".* FROM "blocks"  WHERE "blocks"."name" = ?
+      #
+      # This sanitization step can be disabled by setting the following value to false.
+      # ::Instana.config[:sanitize_sql] = false
+      @config[:sanitize_sql] = true
+
       @config[:action_controller]  = { :enabled => true }
       @config[:action_view]        = { :enabled => true }
       @config[:active_record]      = { :enabled => true }
       @config[:dalli]              = { :enabled => true }
       @config[:excon]              = { :enabled => true }
       @config[:grpc]               = { :enabled => true }
+      @config[:graphql]            = { :enabled => true }
       @config[:nethttp]            = { :enabled => true }
       @config[:redis]              = { :enabled => true }
       @config[:'resque-client']    = { :enabled => true }

data/lib/instana/frameworks/instrumentation/mysql2_adapter.rb

@@ -24,7 +24,13 @@ module Instana
       #
       def collect(sql)
         payload = { :activerecord => {} }
-        payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+
+        if ::Instana.config[:sanitize_sql]
+          payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+        else
+          payload[:activerecord][:sql] = sql
+        end
+
         payload[:activerecord][:adapter] = @config[:adapter]
         payload[:activerecord][:host] = @config[:host]
         payload[:activerecord][:db] = @config[:database]

data/lib/instana/frameworks/instrumentation/mysql_adapter.rb

@@ -21,7 +21,13 @@ module Instana
       #
       def collect(sql)
         payload = { :activerecord => {} }
-        payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+
+        if ::Instana.config[:sanitize_sql]
+          payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+        else
+          payload[:activerecord][:sql] = sql
+        end
+
         payload[:activerecord][:adapter] = @config[:adapter]
         payload[:activerecord][:host] = @config[:host]
         payload[:activerecord][:db] = @config[:database]

data/lib/instana/frameworks/instrumentation/postgresql_adapter.rb

@@ -17,7 +17,6 @@ module Instana
           Instana::Util.method_alias(klass, :exec_delete)
           Instana::Util.method_alias(klass, :execute)
 
-
           @@sanitize_regexp = Regexp.new('(\'[\s\S][^\']*\'|\d*\.\d+|\d+|NULL)', Regexp::IGNORECASE)
         end
       end
@@ -27,14 +26,33 @@ module Instana
       # @param sql [String]
       # @return [Hash] Hash of collected KVs
       #
-      def collect(sql)
+      def collect(sql, binds = nil)
         payload = { :activerecord => {} }
-        payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+
         payload[:activerecord][:adapter] = @config[:adapter]
         payload[:activerecord][:host] = @config[:host]
         payload[:activerecord][:db] = @config[:database]
         payload[:activerecord][:username] = @config[:username]
+
+        if ::Instana.config[:sanitize_sql]
+          payload[:activerecord][:sql] = sql.gsub(@@sanitize_regexp, '?')
+        else
+          # No sanitization so raw SQL and collect up binds
+          payload[:activerecord][:sql] = sql
+
+          # FIXME: Only works on Rails 5 as the bind format varied in previous versions of Rails
+          if binds.is_a?(Array)
+            raw_binds = []
+            binds.each { |x| raw_binds << x.value_before_type_cast }
+            payload[:activerecord][:binds] = raw_binds
+          end
+        end
+
         payload
+      rescue Exception => e
+        ::Instana.logger.debug { "#{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" }
+      ensure
+        return payload
       end
 
       # In the spirit of ::ActiveRecord::ExplainSubscriber.ignore_payload?  There are
@@ -53,7 +71,7 @@ module Instana
           return exec_query_without_instana(sql, name, binds, *args)
         end
 
-        kv_payload = collect(sql)
+        kv_payload = collect(sql, binds)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
           exec_query_without_instana(sql, name, binds, *args)
         end
@@ -64,7 +82,7 @@ module Instana
           return exec_delete_without_instana(sql, name, binds)
         end
 
-        kv_payload = collect(sql)
+        kv_payload = collect(sql, binds)
         ::Instana.tracer.trace(:activerecord, kv_payload) do
           exec_delete_without_instana(sql, name, binds)
         end

data/lib/instana/instrumentation/graphql.rb

@@ -0,0 +1,77 @@
+if defined?(GraphQL::Schema) && defined?(GraphQL::Tracing::PlatformTracing) && ::Instana.config[:graphql][:enabled]
+  module Instana
+    class GraphqlTracing < GraphQL::Tracing::PlatformTracing
+      self.platform_keys = {
+        'lex' => 'lex.graphql',
+        'parse' => 'parse.graphql',
+        'validate' => 'validate.graphql',
+        'analyze_query' => 'analyze.graphql',
+        'analyze_multiplex' => 'analyze.graphql',
+        'execute_multiplex' => 'execute.graphql',
+        'execute_query' => 'execute.graphql',
+        'execute_query_lazy' => 'execute.graphql',
+      }
+      
+      def platform_trace(platform_key, key, data) 
+        return yield unless key == 'execute_query'    
+        operation = data[:query].selected_operation
+            
+        arguments = []
+        fields = []
+        
+        operation.selections.each do |field|
+          arguments.concat(walk_fields(field, :arguments))
+          fields.concat(walk_fields(field, :selections))    
+        end
+            
+        payload = {
+          operationName: data[:query].operation_name || 'anonymous',
+          operationType: operation.operation_type,
+          arguments: grouped_fields(arguments),
+          fields: grouped_fields(fields),
+        }
+                
+        begin
+          ::Instana.tracer.log_entry(:'graphql.server')
+          yield
+        rescue Exception => e
+          ::Instana.tracer.log_error(e)
+          raise e
+        ensure
+          ::Instana.tracer.log_exit(:'graphql.server', {graphql: payload})
+        end
+      end
+    
+      def platform_field_key(type, field)
+        "#{type.graphql_name}.#{field.graphql_name}"
+      end
+      
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized.graphql"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type.graphql"
+      end
+      
+      private
+      
+      def walk_fields(parent, method)
+        return [] unless parent.respond_to?(method)
+        
+        parent.send(method).map do |field|
+          [{object: parent.name, field: field.name}] + walk_fields(field, method)
+        end.flatten
+      end
+      
+      def grouped_fields(fields)
+        fields
+          .group_by { |p| p[:object] }
+          .map { |name, p| [name, p.map { |f| f[:field] }] }
+          .to_h
+      end
+    end
+  end
+  
+  ::GraphQL::Schema.use(::Instana::GraphqlTracing)
+end

data/lib/instana/tracing/span.rb

@@ -3,8 +3,8 @@ module Instana
     REGISTERED_SPANS = [ :actioncontroller, :actionview, :activerecord, :excon,
                          :memcache, :'net-http', :rack, :render, :'rpc-client',
                          :'rpc-server', :'sidekiq-client', :'sidekiq-worker',
-                         :redis, :'resque-client', :'resque-worker' ].freeze
-    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker' ].freeze
+                         :redis, :'resque-client', :'resque-worker', :'graphql.server'  ].freeze
+    ENTRY_SPANS = [ :rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server' ].freeze
     EXIT_SPANS = [ :activerecord, :excon, :'net-http', :'resque-client',
                    :'rpc-client', :'sidekiq-client', :redis ].freeze
     HTTP_SPANS = [ :rack, :excon, :'net-http' ].freeze
@@ -57,9 +57,6 @@ module Instana
       end
 
       if ::Instana.config[:collect_backtraces]
-        # For entry spans, add a backtrace fingerprint
-        add_stack(limit: 2) if ENTRY_SPANS.include?(name)
-
         # Attach a backtrace to all exit spans
         add_stack if EXIT_SPANS.include?(name)
       end
@@ -76,9 +73,11 @@ module Instana
     #
     # @param limit [Integer] Limit the backtrace to the top <limit> frames
     #
-    def add_stack(limit: nil, stack: Kernel.caller)
+    def add_stack(limit: 30, stack: Kernel.caller)
       frame_count = 0
+      sanitized_stack = []
       @data[:stack] = []
+      limit = 40 if limit > 40
 
       stack.each do |i|
         # If the stack has the full instana gem version in it's path
@@ -86,18 +85,23 @@ module Instana
         if !i.match(/instana\/instrumentation\/rack.rb/).nil? ||
           (i.match(::Instana::VERSION_FULL).nil? && i.match('lib/instana/').nil?)
 
-          break if limit && frame_count >= limit
-
           x = i.split(':')
 
-          @data[:stack] << {
+          sanitized_stack << {
             :c => x[0],
             :n => x[1],
             :m => x[2]
           }
-         frame_count = frame_count + 1 if limit
         end
       end
+
+      if sanitized_stack.length > limit
+        # (limit * -1) gives us negative form of <limit> used for
+        # slicing from the end of the list. e.g. stack[-30, 30]
+        @data[:stack] = sanitized_stack[limit*-1, limit]
+      else
+        @data[:stack] = sanitized_stack
+      end
     end
 
     # Log an error into the span

data/lib/instana/version.rb

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

data/test/frameworks/rack_test.rb

@@ -57,11 +57,7 @@ class RackTest < Minitest::Test
     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 rack_span.key?(:stack)
-    assert_equal 2, rack_span[:stack].count
-    refute_nil rack_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
+    assert !rack_span.key?(:stack)
 
     # Restore to default
     ::Instana.config[:collect_backtraces] = false
@@ -233,11 +229,7 @@ class RackTest < Minitest::Test
     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 rack_span.key?(:stack)
-    assert_equal 2, rack_span[:stack].count
-    refute_nil rack_span[:stack].first[:c].match(/instana\/instrumentation\/rack.rb/)
+    assert !rack_span.key?(:stack)
 
     # Restore to default
     ::Instana.config[:collect_backtraces] = false

data/test/frameworks/rails/activerecord_test.rb

@@ -2,7 +2,14 @@ require 'test_helper'
 require 'active_record'
 
 class ActiveRecordTest < Minitest::Test
+
+  def teardown
+    # Make sure defaults are back in place
+    ::Instana.config[:sanitize_sql] = true
+  end
+
   def test_config_defaults
+    assert ::Instana.config[:sanitize_sql] == true
     assert ::Instana.config[:active_record].is_a?(Hash)
     assert ::Instana.config[:active_record].key?(:enabled)
     assert_equal true, ::Instana.config[:active_record][:enabled]
@@ -28,19 +35,14 @@ class ActiveRecordTest < Minitest::Test
       assert span[:data][:activerecord].key?(:username)
     end
 
-
-    found = false
     if ::Rails::VERSION::MAJOR < 4
       sql = "INSERT INTO \"blocks\" (\"color\", \"created_at\", \"name\", \"updated_at\") VALUES ($?, $?, $?, $?) RETURNING \"id\""
     else
       sql = "INSERT INTO \"blocks\" (\"name\", \"color\", \"created_at\", \"updated_at\") VALUES ($?, $?, $?, $?) RETURNING \"id\""
     end
-    ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] ==
-        found = true
-      end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
     end
-    assert found
 
     found = false
     if ::Rails::VERSION::MAJOR >= 5
@@ -50,12 +52,9 @@ class ActiveRecordTest < Minitest::Test
     else
       sql = "SELECT  \"blocks\".* FROM \"blocks\"  WHERE \"blocks\".\"name\" = ? LIMIT ?"
     end
-    ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] == sql
-        found = true
-      end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
     end
-    assert found
 
     found = false
     if ::Rails::VERSION::MAJOR == 3
@@ -63,12 +62,73 @@ class ActiveRecordTest < Minitest::Test
     else
       sql = "DELETE FROM \"blocks\" WHERE \"blocks\".\"id\" = $?"
     end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
+    end
+  end
+
+  def test_postgresql_without_sanitize
+    skip unless ::Instana::Test.postgresql?
+
+    # Shut SQL sanitization off
+    ::Instana.config[:sanitize_sql] = false
+    # Pause so the thread can syncronize values
+    sleep 1
+
+    clear_all!
+
+    Net::HTTP.get(URI.parse('http://localhost:3205/test/db'))
+
+    spans = Instana.processor.queued_spans
+    assert_equal 6, spans.length
+    rack_span = find_first_span_by_name(spans, :rack)
+
+    ar_spans = find_spans_by_name(spans, :activerecord)
+    assert_equal 3, ar_spans.length
+
     ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] == sql
-        found = true
-      end
+      assert_equal "postgresql", span[:data][:activerecord][:adapter]
+      assert span[:data][:activerecord].key?(:host)
+      assert span[:data][:activerecord].key?(:username)
+    end
+
+    if ::Rails::VERSION::MAJOR < 4
+      sql = "INSERT INTO \"blocks\" (\"color\", \"created_at\", \"name\", \"updated_at\") VALUES ($1, $2, $3, $4) RETURNING \"id\""
+    else
+      sql = "INSERT INTO \"blocks\" (\"name\", \"color\", \"created_at\", \"updated_at\") VALUES ($1, $2, $3, $4) RETURNING \"id\""
     end
-    assert found
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
+    end
+    assert ar_span[:data][:activerecord].key?(:binds)
+    assert ar_span[:data][:activerecord][:binds].is_a?(Array)
+    assert_equal 4, ar_span[:data][:activerecord][:binds].length
+
+    if ::Rails::VERSION::MAJOR >= 5
+      sql = "SELECT  \"blocks\".* FROM \"blocks\" WHERE \"blocks\".\"name\" = $1 ORDER BY \"blocks\".\"id\" ASC LIMIT $2"
+    elsif ::Rails::VERSION::MAJOR == 4
+      sql = "SELECT  \"blocks\".* FROM \"blocks\" WHERE \"blocks\".\"name\" = $?  ORDER BY \"blocks\".\"id\" ASC LIMIT ?"
+    else
+      sql = "SELECT  \"blocks\".* FROM \"blocks\"  WHERE \"blocks\".\"name\" = ? LIMIT ?"
+    end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
+    end
+    assert ar_span[:data][:activerecord].key?(:binds)
+    assert ar_span[:data][:activerecord][:binds].is_a?(Array)
+    assert_equal 2, ar_span[:data][:activerecord][:binds].length
+
+    if ::Rails::VERSION::MAJOR == 3
+      sql = "DELETE FROM \"blocks\" WHERE \"blocks\".\"id\" = 1"
+    else
+      sql = "DELETE FROM \"blocks\" WHERE \"blocks\".\"id\" = $1"
+    end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == sql
+    end
+    assert ar_span[:data][:activerecord].key?(:binds)
+    assert ar_span[:data][:activerecord][:binds].is_a?(Array)
+    assert_equal 1, ar_span[:data][:activerecord][:binds].length
   end
 
   def test_postgresql_lock_table
@@ -93,21 +153,13 @@ class ActiveRecordTest < Minitest::Test
       assert_equal "postgres", ar_span[:data][:activerecord][:username]
     end
 
-    found = false
-    ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] == "LOCK blocks IN ACCESS EXCLUSIVE MODE"
-        found = true
-      end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == "LOCK blocks IN ACCESS EXCLUSIVE MODE"
     end
-    assert found
 
-    found = false
-    ar_spans.each do |span|
-      if span[:data][:activerecord][:sql] == "SELECT ?"
-        found = true
-      end
+    ar_span = find_first_span_by_qualifier(ar_spans) do |span|
+      span[:data][:activerecord][:sql] == "SELECT ?"
     end
-    assert found
   end
 
   def test_postgresql_raw_execute

data/test/instrumentation/excon_test.rb

@@ -116,8 +116,6 @@ class ExconTest < Minitest::Test
     assert_equal 3, rack_spans.length
     assert_equal 3, excon_spans.length
 
-    # ::Instana::Util.pry!
-
     for rack_span in rack_spans
       # data keys/values
       refute_nil rack_span.key?(:data)

data/test/instrumentation/graphql_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+class GraphqlTest < Minitest::Test
+  class TaskType < GraphQL::Schema::Object
+    field :id, ID, null: false
+    field :action, String, null: false
+  end
+  
+  class NewTaskType < GraphQL::Schema::Mutation
+    argument :action, String, required: true
+    field :task, TaskType, null: true
+    
+    def resolve(action:)
+      {
+        task: OpenStruct.new(id: '0', action: action)
+      }
+    end
+  end
+  
+  class QueryType < GraphQL::Schema::Object
+    field :tasks, TaskType.connection_type, null: false
+    
+    def tasks()
+      [
+        OpenStruct.new(id: '0', action: 'Sample')
+      ]
+    end
+  end
+  
+  class MutationType < GraphQL::Schema::Object
+    field :create_task, mutation: NewTaskType
+  end
+  
+  class Schema < GraphQL::Schema
+    query QueryType
+    mutation MutationType
+  end
+  
+  def test_it_works
+    assert defined?(GraphQL)
+  end
+  
+  def test_config_defaults    
+    assert ::Instana.config[:graphql].is_a?(Hash)
+    assert ::Instana.config[:graphql].key?(:enabled)
+    assert_equal true, ::Instana.config[:graphql][:enabled]
+  end
+  
+  def test_query
+    clear_all!
+    
+    query = "query Sample {
+      tasks(after: \"\", first: 10) {
+        nodes {
+          action
+        }
+      }
+    }"
+    
+    expected_data = {
+      :operationName => "Sample",
+      :operationType => "query",
+      :arguments => { "tasks" => ["after", "first"] },
+      :fields => { "tasks" => ["nodes"], "nodes" => ["action"] }
+    }
+    expected_results = {
+      "data" => {
+        "tasks" => { 
+          "nodes" => [{ "action" => "Sample" }]
+        }
+      }
+    }
+    
+    results = Instana.tracer.start_or_continue_trace('graphql-test') { Schema.execute(query) }
+    query_span, root_span = *Instana.processor.queued_spans
+    
+    assert_equal expected_results, results.to_h
+    assert_equal :sdk, root_span[:n]
+    assert_equal :'graphql.server', query_span[:n]
+    assert_equal expected_data, query_span[:data][:graphql]
+  end
+  
+  def test_mutation
+    clear_all!
+    
+    query = "mutation Sample {
+      createTask(action: \"Sample\") {
+        task {
+          action
+        }
+      }
+    }"
+    
+    expected_data = {
+      :operationName => "Sample",
+      :operationType => "mutation",
+      :arguments => { "createTask" => ["action"] },
+      :fields => { "createTask" => ["task"], "task" => ["action"] }
+    }
+    expected_results = {
+      "data" => {
+        "createTask" => { 
+          "task" => { "action" => "Sample" }
+        }
+      }
+    }
+    
+    results = Instana.tracer.start_or_continue_trace('graphql-test') { Schema.execute(query) }
+    query_span, root_span = *Instana.processor.queued_spans
+        
+    assert_equal expected_results, results.to_h
+    assert_equal :sdk, root_span[:n]
+    assert_equal :'graphql.server', query_span[:n]
+    assert_equal expected_data, query_span[:data][:graphql]
+  end
+end

data/test/instrumentation/redis_test.rb

@@ -20,6 +20,16 @@ class RedisTest < Minitest::Test
     assert_redis_trace('SET')
   end
 
+  def test_georadius
+    clear_all!
+
+    Instana.tracer.start_or_continue_trace(:redis_test) do
+      @redis_client.georadius('Sicily', '15', '37', '200', 'km', 'WITHCOORD', 'WITHDIST')
+    end
+
+    assert_redis_trace('GEORADIUS')
+  end
+
   def test_normal_call_with_error
     clear_all!
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: instana
 version: !ruby/object:Gem::Version
-  version: 1.13.0
+  version: 1.192.0
 platform: ruby
 authors:
 - Peter Giacomo Lombardo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-01-08 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -231,6 +231,7 @@ files:
 - lib/instana/instrumentation.rb
 - lib/instana/instrumentation/dalli.rb
 - lib/instana/instrumentation/excon.rb
+- lib/instana/instrumentation/graphql.rb
 - lib/instana/instrumentation/grpc.rb
 - lib/instana/instrumentation/net-http.rb
 - lib/instana/instrumentation/rack.rb
@@ -275,6 +276,7 @@ files:
 - test/instana_test.rb
 - test/instrumentation/dalli_test.rb
 - test/instrumentation/excon_test.rb
+- test/instrumentation/graphql_test.rb
 - test/instrumentation/grpc_test.rb
 - test/instrumentation/net-http_test.rb
 - test/instrumentation/redis_test.rb
@@ -338,6 +340,7 @@ test_files:
 - test/models/block.rb
 - test/models/block6.rb
 - test/secrets_test.rb
+- test/instrumentation/graphql_test.rb
 - test/instrumentation/sidekiq-client_test.rb
 - test/instrumentation/resque_test.rb
 - test/instrumentation/sidekiq-worker_test.rb