instana 2.0.0 → 2.2.0

data/test/instrumentation/graphql_test.rb

@@ -1,289 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2021
-
-require 'test_helper'
-
-class GraphqlTest < Minitest::Test
-  class TaskType < GraphQL::Schema::Object
-    field :id, ID, null: false
-    field :action, String, null: false
-  end
-
-  class JobType < GraphQL::Schema::Object
-    field :id, ID, null: false
-    field :name, String, null: false
-    field :description, String, null: false
-  end
-
-  class TaskJobUnion < GraphQL::Schema::Union
-    description "A union type for Task and Job"
-    possible_types TaskType, JobType
-
-    def self.resolve_type(object, _context)
-      if !object.action.nil?
-        TaskType
-      elsif !object.description?
-        JobType
-      else
-        raise("Unexpected object: #{object}")
-      end
-    end
-  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
-    field :jobs, JobType.connection_type, null: false
-    field :tasksorjobs, TaskJobUnion.connection_type, null: false
-
-    def tasks()
-      [
-        OpenStruct.new(id: '0', action: 'Sample 00'),
-        OpenStruct.new(id: '1', action: 'Sample 01'),
-        OpenStruct.new(id: '2', action: 'Sample 02'),
-        OpenStruct.new(id: '3', action: 'Sample 03'),
-        OpenStruct.new(id: '4', action: 'Sample 04')
-      ]
-    end
-
-    def jobs()
-      [
-        OpenStruct.new(id: '0', name: 'Name 00', description: 'Desc 00'),
-        OpenStruct.new(id: '1', name: 'Name 01', description: 'Desc 01'),
-        OpenStruct.new(id: '2', name: 'Name 02', description: 'Desc 02'),
-        OpenStruct.new(id: '3', name: 'Name 03', description: 'Desc 03'),
-        OpenStruct.new(id: '4', name: 'Name 04', description: 'Desc 04')
-      ]
-    end
-
-    def tasksorjobs()
-      [
-        OpenStruct.new(id: '0', action: 'Task 00'),
-        OpenStruct.new(id: '0', name: 'Job 00', description: 'Job Desc 00')
-      ]
-    end
-  end
-
-  class MutationType < GraphQL::Schema::Object
-    field :create_task, mutation: NewTaskType
-  end
-
-  class Schema < GraphQL::Schema
-    query QueryType
-    mutation MutationType
-  end
-
-  def teardown
-    ::Instana.config[:allow_exit_as_root] = false
-  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 FirstTwoTaskSamples {
-      tasks(after: \"\", first: 2) {
-        nodes {
-          action
-        }
-      }
-    }"
-
-    expected_data = {
-      :operationName => "FirstTwoTaskSamples",
-      :operationType => "query",
-      :arguments => { "tasks" => ["after", "first"] },
-      :fields => { "tasks" => ["nodes"], "nodes" => ["action"] }
-    }
-    expected_results = {
-      "data" => {
-        "tasks" => {
-          "nodes" => [{"action" => "Sample 00"}, {"action" => "Sample 01"}]
-        }
-      }
-    }
-
-    results = Instana.tracer.in_span('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_query_as_root_exit_span
-    clear_all!
-
-    query = "query FirstTwoTaskSamples {
-      tasks(after: \"\", first: 2) {
-        nodes {
-          action
-        }
-      }
-    }"
-
-    expected_data = {
-      :operationName => "FirstTwoTaskSamples",
-      :operationType => "query",
-      :arguments => { "tasks" => ["after", "first"] },
-      :fields => { "tasks" => ["nodes"], "nodes" => ["action"] }
-    }
-    expected_results = {
-      "data" => {
-        "tasks" => {
-          "nodes" => [{"action" => "Sample 00"}, {"action" => "Sample 01"}]
-        }
-      }
-    }
-
-    ::Instana.config[:allow_exit_as_root] = true
-    results = Schema.execute(query)
-    ::Instana.config[:allow_exit_as_root] = false
-    queued_spans = Instana.processor.queued_spans
-    assert_equal 1, queued_spans.length
-    query_span = queued_spans[0]
-
-    assert_equal expected_results, results.to_h
-    assert_equal :'graphql.server', query_span[:n]
-    assert_equal expected_data, query_span[:data][:graphql]
-  end
-
-  def test_query_with_fragment
-    clear_all!
-
-    query = "
-    fragment actionDetails on Task {
-      action
-    }
-
-    query SampleWithFragment {
-      tasks {
-        nodes {
-          ... actionDetails
-        }
-      }
-    }"
-
-    expected_data = {
-      :operationName => "SampleWithFragment",
-      :operationType => "query",
-      :arguments => {},
-      :fields => { "tasks" => ["nodes"], "nodes" => ["actionDetails"] }
-    }
-    expected_results = {
-      "data" => {
-        "tasks" => {
-          "nodes" => [{"action" => "Sample 00"}, {"action" => "Sample 01"},
-                      {"action" => "Sample 02"}, {"action" => "Sample 03"},
-                      {"action" => "Sample 04"}]
-        }
-      }
-    }
-
-    results = Instana.tracer.in_span('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_query_union_with_fragment
-    clear_all!
-
-    query = "
-    query QueryUnionWithFragment {
-      tasksorjobs {
-        nodes {
-          ... on Task {
-            action
-          }
-          ... on Job {
-            name
-            description
-          }
-        }
-      }
-    }"
-
-    expected_data = {
-      :operationName => "QueryUnionWithFragment",
-      :operationType => "query",
-      :arguments => {},
-      :fields => { "tasksorjobs" => ["nodes"],
-                   "nodes" => ["InlineFragment", "InlineFragment"],
-                   "InlineFragment" => %w[action name description]}
-    }
-    expected_results = {
-      "data" => {
-        "tasksorjobs" => {
-          "nodes" => [{"action" => "Task 00"},
-                      {"name" => "Job 00", "description" => "Job Desc 00"}]
-        }
-      }
-    }
-
-    results = Instana.tracer.in_span('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.in_span('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/grpc_test.rb

@@ -1,420 +0,0 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2017
-
-require 'test_helper'
-require 'support/apps/grpc/boot'
-
-class GrpcTest < Minitest::Test # rubocop:disable Metrics/ClassLength
-  def client_stub
-    PingPongService::Stub.new('127.0.0.1:50051', :this_channel_is_insecure)
-  end
-
-  def teardown
-    ::Instana.config[:allow_exit_as_root] = false
-  end
-
-  def assert_client_span(client_span, call: '', call_type: '', error: nil)
-    data = client_span[:data]
-    assert_equal '127.0.0.1:50051', data[:rpc][:host]
-    assert_equal :grpc, data[:rpc][:flavor]
-    assert_equal call, data[:rpc][:call]
-    assert_equal call_type, data[:rpc][:call_type]
-
-    if error
-      assert_equal true, data[:rpc][:error]
-      assert data[:log][:message].include?("2:RuntimeError: #{error}")
-    end
-  end
-
-  def assert_server_span(server_span, call: '', call_type: '', error: nil)
-    # Span name validation
-    assert_equal :'rpc-server', server_span[:n]
-
-    data = server_span[:data]
-    assert_equal :grpc, data[:rpc][:flavor]
-    assert_equal call, data[:rpc][:call]
-    assert_equal call_type, data[:rpc][:call_type]
-
-    if error
-      assert_equal true, data[:rpc][:error]
-      assert_equal error, data[:log][:message]
-    end
-  end
-
-  def test_request_response
-    clear_all!
-    response = nil
-
-    Instana.tracer.in_span(:rpctests) do
-      response = client_stub.ping(
-        PingPongService::PingRequest.new(message: 'Hello World')
-      )
-    end
-    sleep 1
-
-    assert 'Hello World', response.message
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    sdk_span = find_spans_by_name(spans, :rpctests).first
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    validate_sdk_span(sdk_span)
-
-    assert_client_span(
-        client_span,
-        call: '/PingPongService/Ping',
-        call_type: :request_response
-    )
-
-    assert_server_span(
-        server_span,
-        call: '/PingPongService/Ping',
-        call_type: :request_response
-    )
-
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, client_span[:t]
-    assert_equal trace_id, server_span[:t]
-
-    assert_equal server_span[:p], client_span[:s]
-    assert_equal client_span[:p], sdk_span[:s]
-  end
-
-  def test_request_response_as_root_exit_span
-    clear_all!
-    ::Instana.config[:allow_exit_as_root] = true
-
-    response = client_stub.ping(
-      PingPongService::PingRequest.new(message: 'Hello World')
-    )
-    sleep 1
-
-    assert 'Hello World', response.message
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    assert_client_span(
-        client_span,
-        call: '/PingPongService/Ping',
-        call_type: :request_response
-    )
-
-    assert_server_span(
-        server_span,
-        call: '/PingPongService/Ping',
-        call_type: :request_response
-    )
-
-    assert_equal client_span[:t], server_span[:t]
-    assert_equal client_span[:s], server_span[:p]
-    assert_nil client_span[:p]
-  end
-
-  def test_client_streamer
-    clear_all!
-    response = nil
-
-    Instana.tracer.in_span(:rpctests) do
-      response = client_stub.ping_with_client_stream(
-        (0..5).map do |index|
-          PingPongService::PingRequest.new(message: index.to_s)
-        end
-      )
-    end
-    sleep 1
-
-    assert '01234', response.message
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    sdk_span = find_spans_by_name(spans, :rpctests).first
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    validate_sdk_span(sdk_span)
-
-    assert_client_span(
-        client_span,
-        call: '/PingPongService/PingWithClientStream',
-        call_type: :client_streamer
-    )
-
-    assert_server_span(
-        server_span,
-        call: '/PingPongService/PingWithClientStream',
-        call_type: :client_streamer
-    )
-
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, client_span[:t]
-    assert_equal trace_id, server_span[:t]
-
-    assert_equal server_span[:p], client_span[:s]
-    assert_equal client_span[:p], sdk_span[:s]
-  end
-
-  def test_server_streamer
-    clear_all!
-    responses = []
-
-    Instana.tracer.in_span(:rpctests) do
-      responses = client_stub.ping_with_server_stream(
-        PingPongService::PingRequest.new(message: 'Hello World')
-      )
-    end
-    assert %w(0 1 2 3 4), responses.map(&:message)
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    sdk_span = find_spans_by_name(spans, :rpctests).first
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    validate_sdk_span(sdk_span)
-
-    assert_client_span(
-        client_span,
-        call: '/PingPongService/PingWithServerStream',
-        call_type: :server_streamer
-    )
-
-    assert_server_span(
-        server_span,
-        call: '/PingPongService/PingWithServerStream',
-        call_type: :server_streamer
-    )
-
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, client_span[:t]
-    assert_equal trace_id, server_span[:t]
-
-    assert_equal server_span[:p], client_span[:s]
-    assert_equal client_span[:p], sdk_span[:s]
-  end
-
-  def test_bidi_streamer
-    clear_all!
-    responses = []
-
-    Instana.tracer.in_span(:rpctests) do
-      responses = client_stub.ping_with_bidi_stream(
-        (0..5).map do |index|
-          PingPongService::PingRequest.new(message: (index * 2).to_s)
-        end
-      )
-    end
-    sleep 1
-
-    assert %w(0 2 4 6 8), responses.to_a.map(&:message)
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    sdk_span = find_spans_by_name(spans, :rpctests).first
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    validate_sdk_span(sdk_span)
-
-    assert_client_span(
-        client_span,
-        call: '/PingPongService/PingWithBidiStream',
-        call_type: :bidi_streamer
-    )
-
-    assert_server_span(
-        server_span,
-        call: '/PingPongService/PingWithBidiStream',
-        call_type: :bidi_streamer
-    )
-
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, client_span[:t]
-    assert_equal trace_id, server_span[:t]
-
-    assert_equal server_span[:p], client_span[:s]
-    assert_equal client_span[:p], sdk_span[:s]
-  end
-
-  def test_request_response_failure
-    clear_all!
-    Instana.tracer.in_span(:rpctests) do
-      begin
-        client_stub.fail_to_ping( PingPongService::PingRequest.new(message: 'Hello World'))
-      rescue
-      end
-    end
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    sdk_span = find_spans_by_name(spans, :rpctests).first
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    validate_sdk_span(sdk_span)
-
-    assert_client_span(
-        client_span,
-        call: '/PingPongService/FailToPing',
-        call_type: :request_response,
-        error: 'Unexpected failed'
-    )
-    assert_server_span(
-        server_span,
-        call: '/PingPongService/FailToPing',
-        call_type: :request_response,
-        error: 'Unexpected failed'
-    )
-
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, client_span[:t]
-    assert_equal trace_id, server_span[:t]
-
-    assert_equal server_span[:p], client_span[:s]
-    assert_equal client_span[:p], sdk_span[:s]
-  end
-
-  def test_client_streamer_failure
-    clear_all!
-    Instana.tracer.in_span(:rpctests) do
-      begin
-        client_stub.fail_to_ping_with_client_stream(
-          (0..5).map do |index|
-            PingPongService::PingRequest.new(message: index.to_s)
-          end
-        )
-      rescue
-      end
-    end
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    sdk_span = find_spans_by_name(spans, :rpctests).first
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    validate_sdk_span(sdk_span)
-
-    assert_client_span(
-      client_span,
-      call: '/PingPongService/FailToPingWithClientStream',
-      call_type: :client_streamer,
-      error: 'Unexpected failed'
-    )
-
-    assert_server_span(
-      server_span,
-      call: '/PingPongService/FailToPingWithClientStream',
-      call_type: :client_streamer,
-      error: 'Unexpected failed'
-    )
-
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, client_span[:t]
-    assert_equal trace_id, server_span[:t]
-
-    assert_equal server_span[:p], client_span[:s]
-    assert_equal client_span[:p], sdk_span[:s]
-  end
-
-  def test_server_streamer_failure
-    clear_all!
-    Instana.tracer.in_span(:rpctests) do
-      begin
-        client_stub.fail_to_ping_with_server_stream(
-          PingPongService::PingRequest.new(message: 'Hello World')
-        )
-      rescue
-      end
-    end
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    sdk_span = find_spans_by_name(spans, :rpctests).first
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    validate_sdk_span(sdk_span)
-
-    assert_client_span(
-      client_span,
-      call: '/PingPongService/FailToPingWithServerStream',
-      call_type: :server_streamer
-    )
-
-    assert_server_span(
-      server_span,
-      call: '/PingPongService/FailToPingWithServerStream',
-      call_type: :server_streamer,
-      error: 'Unexpected failed'
-    )
-
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, client_span[:t]
-    assert_equal trace_id, server_span[:t]
-
-    assert_equal server_span[:p], client_span[:s]
-    assert_equal client_span[:p], sdk_span[:s]
-  end
-
-  def test_bidi_streamer_failure
-    clear_all!
-    Instana.tracer.in_span(:rpctests) do
-      client_stub.fail_to_ping_with_bidi_stream(
-        (0..5).map do |index|
-          PingPongService::PingRequest.new(message: (index * 2).to_s)
-        end
-      )
-    end
-
-    # Pause for a split second to allow traces to be queued
-    sleep 0.2
-
-    spans = ::Instana.processor.queued_spans
-    sdk_span = find_spans_by_name(spans, :rpctests).first
-    client_span = find_spans_by_name(spans, :'rpc-client').first
-    server_span = find_spans_by_name(spans, :'rpc-server').first
-
-    validate_sdk_span(sdk_span)
-
-    assert_client_span(
-      client_span,
-      call: '/PingPongService/FailToPingWithBidiStream',
-      call_type: :bidi_streamer
-    )
-
-    assert_server_span(
-      server_span,
-      call: '/PingPongService/FailToPingWithBidiStream',
-      call_type: :bidi_streamer,
-      error: 'Unexpected failed'
-    )
-
-    trace_id = sdk_span[:t]
-    assert_equal trace_id, client_span[:t]
-    assert_equal trace_id, server_span[:t]
-
-    assert_equal server_span[:p], client_span[:s]
-    assert_equal client_span[:p], sdk_span[:s]
-  end
-end