Module: Datadog::Tracing::Contrib::GraphQL::UnifiedTrace

Includes:
GraphQL::Tracing::PlatformTrace
Defined in:
lib/datadog/tracing/contrib/graphql/unified_trace.rb

Overview

These methods will be called by the GraphQL runtime to trace the execution of queries. This tracer differs from the upstream one as it follows the unified naming convention specification, which is required to use features such as API Catalog. DEV-3.0: This tracer should be the default one in the next major version.

Instance Method Summary collapse

Instance Method Details

#analyze_multiplex(*args, multiplex:, **kwargs) ⇒ Object 



69
70
71
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 69

def analyze_multiplex(*args, multiplex:, **kwargs)
  trace(proc { super }, 'analyze_multiplex', multiplex_resource(multiplex), multiplex: multiplex)
end

#analyze_query(*args, query:, **kwargs) ⇒ Object 



73
74
75
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 73

def analyze_query(*args, query:, **kwargs)
  trace(proc { super }, 'analyze', query.query_string, query: query)
end

#authorized(*args, **kwargs) ⇒ Object 



146
147
148
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 146

def authorized(*args, **kwargs)
  authorized_span(proc { super }, 'authorized', **kwargs)
end

#authorized_lazy(*args, **kwargs) ⇒ Object 



150
151
152
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 150

def authorized_lazy(*args, **kwargs)
  authorized_span(proc { super }, 'authorized_lazy', **kwargs)
end

#authorized_span(callable, span_key, **kwargs) ⇒ Object 



141
142
143
144
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 141

def authorized_span(callable, span_key, **kwargs)
  platform_key = @platform_key_cache[UnifiedTrace].platform_authorized_key_cache[kwargs[:type]]
  trace(callable, span_key, platform_key, **kwargs)
end

#execute_field(*args, **kwargs) ⇒ Object 



133
134
135
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 133

def execute_field(*args, **kwargs)
  execute_field_span(proc { super }, 'resolve', **kwargs)
end

#execute_field_lazy(*args, **kwargs) ⇒ Object 



137
138
139
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 137

def execute_field_lazy(*args, **kwargs)
  execute_field_span(proc { super }, 'resolve_lazy', **kwargs)
end

#execute_field_span(callable, span_key, **kwargs) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 118

def execute_field_span(callable, span_key, **kwargs)
  # @platform_key_cache is initialized upstream, in ::GraphQL::Tracing::PlatformTrace
  platform_key = @platform_key_cache[UnifiedTrace].platform_field_key_cache[kwargs[:field]]

  if platform_key
    trace(callable, span_key, platform_key, **kwargs) do |span|
      kwargs[:arguments].each do |key, value|
        span.set_tag("graphql.variables.#{key}", value)
      end
    end
  else
    callable.call
  end
end

#execute_multiplex(*args, multiplex:, **kwargs) ⇒ Object 



77
78
79
80
81
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 77

def execute_multiplex(*args, multiplex:, **kwargs)
  trace(proc { super }, 'execute_multiplex', multiplex_resource(multiplex), multiplex: multiplex) do |span|
    span.set_tag('graphql.source', "Multiplex[#{multiplex.queries.map(&:query_string).join(", ")}]")
  end
end

#execute_query(*args, query:, **kwargs) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 83

def execute_query(*args, query:, **kwargs)
  trace(
    proc { super },
    'execute',
    operation_resource(query.selected_operation),
    lambda { |span|
      # Ensure this span can be aggregated by in the Datadog App, and generates RED metrics.
      span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)

      span.set_tag('graphql.source', query.query_string)
      span.set_tag('graphql.operation.type', query.selected_operation&.operation_type)
      if query.selected_operation_name
        span.set_tag(
          'graphql.operation.name',
          query.selected_operation_name
        )
      end
      query.variables.instance_variable_get(:@storage).each do |key, value|
        span.set_tag("graphql.variables.#{key}", value)
      end
    },
    ->(span) { add_query_error_events(span, query.context.errors) },
    query: query,
  )
end

#execute_query_lazy(*args, query:, multiplex:, **kwargs) ⇒ Object 



109
110
111
112
113
114
115
116
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 109

def execute_query_lazy(*args, query:, multiplex:, **kwargs)
  resource = if query
    query.selected_operation_name || fallback_transaction_name(query.context)
  else
    multiplex_resource(multiplex)
  end
  trace(proc { super }, 'execute_lazy', resource, query: query, multiplex: multiplex)
end

#initialize(*args, **kwargs) ⇒ Object 



16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 16

def initialize(*args, **kwargs)
  @has_prepare_span = respond_to?(:prepare_span)

  # Cache configuration values to avoid repeated lookups
  config = Datadog.configuration.tracing[:graphql]
  @service_name = config[:service_name]
  @analytics_enabled = config[:analytics_enabled]
  @analytics_sample_rate = config[:analytics_sample_rate]
  @error_extensions_config = config[:error_extensions]

  load_error_event_attributes(config[:error_tracking])

  super
end

#lex(*args, query_string:, **kwargs) ⇒ Object 



53
54
55
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 53

def lex(*args, query_string:, **kwargs)
  trace(proc { super }, 'lex', query_string, query_string: query_string)
end

#parse(*args, query_string:, **kwargs) ⇒ Object 



57
58
59
60
61
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 57

def parse(*args, query_string:, **kwargs)
  trace(proc { super }, 'parse', query_string, query_string: query_string) do |span|
    span.set_tag('graphql.source', query_string)
  end
end

#platform_authorized_key(type, *args, **kwargs) ⇒ Object 



171
172
173
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 171

def platform_authorized_key(type, *args, **kwargs)
  "#{type.graphql_name}.authorized"
end

#platform_field_key(field, *args, **kwargs) ⇒ Object 



167
168
169
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 167

def platform_field_key(field, *args, **kwargs)
  field.path
end

#platform_resolve_type_key(type, *args, **kwargs) ⇒ Object 



175
176
177
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 175

def platform_resolve_type_key(type, *args, **kwargs)
  "#{type.graphql_name}.resolve_type"
end

#resolve_type(*args, **kwargs) ⇒ Object 



159
160
161
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 159

def resolve_type(*args, **kwargs)
  resolve_type_span(proc { super }, 'resolve_type', **kwargs)
end

#resolve_type_lazy(*args, **kwargs) ⇒ Object 



163
164
165
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 163

def resolve_type_lazy(*args, **kwargs)
  resolve_type_span(proc { super }, 'resolve_type_lazy', **kwargs)
end

#resolve_type_span(callable, span_key, **kwargs) ⇒ Object 



154
155
156
157
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 154

def resolve_type_span(callable, span_key, **kwargs)
  platform_key = @platform_key_cache[UnifiedTrace].platform_resolve_type_key_cache[kwargs[:type]]
  trace(callable, span_key, platform_key, **kwargs)
end

#validate(*args, query:, validate:, **kwargs) ⇒ Object 



63
64
65
66
67
 
# File 'lib/datadog/tracing/contrib/graphql/unified_trace.rb', line 63

def validate(*args, query:, validate:, **kwargs)
  trace(proc { super }, 'validate', query.selected_operation_name, query: query, validate: validate) do |span|
    span.set_tag('graphql.source', query.query_string)
  end
end