graphql 1.13.12 → 1.13.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90fcd1d4c840be80d47ed66bad6c4cdd4c16a4981b249b57e7e126a3ff5d5d6d
-  data.tar.gz: 6d9f87843cd626dff3a9f46158fce7f1be22c3f1aa4131c8b2390b82f93edb52
+  metadata.gz: 2a586eb14f15e3215e732634aa6edd2204127fe1dbf356c7ff45a0b96b794832
+  data.tar.gz: 69acba1a940532a8010160fd0bbd4ab4d2a22d6985f4057d030815599f13f5fb
 SHA512:
-  metadata.gz: 355972194b55f12d4bc43d610249c94ce6d73c574f12688863b01bf60ad4f2a9ad093ee19c76403f4b84371583ea5c236a3d7cfda72e3564a222dd9f12c1d0ea
-  data.tar.gz: 5ebd795ac0884a46f413e4ede96165d3b2be2489266c36fbc06d90f0d940e69a2afa86c86417757716dc47ddc9c3bdbbe475c7f1547951c5cbe843a0ed7d45e5
+  metadata.gz: db2ab29ba5535a1f60ee549542bb528323af2cb8789cc0c3e05586bc20ebb02b11b67a1d3ee7224180f437ee07e52d59f76974e5d5a476a6add5e0142ea7557e
+  data.tar.gz: 6c5e5c0ada2c8a293c86e338ede7bf22dee1a699b0ac8aa866993ce849de95e0683a576e2459eb199d45d30b17d745654e4ce73a95bf77704d2cd5af0a31d50f

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -17,15 +17,21 @@ module GraphQL
       def platform_trace(platform_key, key, data)
         tracer.trace(platform_key, service: service_name) do |span|
           span.span_type = 'custom'
+          if defined?(Datadog::Tracing::Metadata::Ext) # Introduced in ddtrace 1.0
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_COMPONENT, 'graphql')
+            span.set_tag(Datadog::Tracing::Metadata::Ext::TAG_OPERATION, key)
+          end
 
           if key == 'execute_multiplex'
             operations = data[:multiplex].queries.map(&:selected_operation_name).join(', ')
-            span.resource = if operations.empty?
+
+            resource = if operations.empty?
               first_query = data[:multiplex].queries.first
               fallback_transaction_name(first_query && first_query.context)
             else
               operations
             end
+            span.resource = resource if resource
 
             # For top span of query, set the analytics sample rate tag, if available.
             if analytics_enabled?
@@ -39,6 +45,8 @@ module GraphQL
             span.set_tag(:query_string, data[:query].query_string)
           end
 
+          prepare_span(key, data, span)
+
           yield
         end
       end
@@ -47,6 +55,13 @@ module GraphQL
         options.fetch(:service, 'ruby-graphql')
       end
 
+      # Implement this method in a subclass to apply custom tags to datadog spans
+      # @param key [String] The event being traced
+      # @param data [Hash] The runtime data for this event (@see GraphQL::Tracing for keys for each event)
+      # @param span [Datadog::Tracing::SpanOperation] The datadog span for this event
+      def prepare_span(key, data, span)
+      end
+
       def tracer
         options.fetch(:tracer, Datadog.tracer)
       end

data/lib/graphql/tracing/opentelemetry_tracing.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class OpenTelemetryTracing < PlatformTracing
+      self.platform_keys = {
+        'lex' => 'graphql.lex',
+        'parse' => 'graphql.parse',
+        'validate' => 'graphql.validate',
+        'analyze_query' => 'graphql.analyze_query',
+        'analyze_multiplex' => 'graphql.analyze_multiplex',
+        'execute_query' => 'graphql.execute_query',
+        'execute_query_lazy' => 'graphql.execute_query_lazy',
+        'execute_multiplex' => 'graphql.execute_multiplex'
+      }
+
+      def platform_trace(platform_key, key, data)
+        return yield if platform_key.nil?
+
+        tracer.in_span(platform_key, attributes: attributes_for(key, data)) do |span, _context|
+          yield.tap do |response|
+            errors = response[:errors]&.compact&.map { |e| e.to_h }&.to_json if key == 'validate'
+            unless errors.nil?
+              span.add_event(
+                'graphql.validation.error',
+                attributes: {
+                  'message' => errors
+                }
+              )
+            end
+          end
+        end
+      end
+
+      def platform_field_key(type, field)
+        "#{type.graphql_name}.#{field.graphql_name}"
+      end
+
+      def platform_authorized_key(type)
+        "#{type.graphql_name}.authorized"
+      end
+
+      def platform_resolve_type_key(type)
+        "#{type.graphql_name}.resolve_type"
+      end
+
+      private
+
+      def tracer
+        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.tracer
+      end
+
+      def config
+        OpenTelemetry::Instrumentation::GraphQL::Instrumentation.instance.config
+      end
+
+      def platform_key_enabled?(ctx, key)
+        return false unless config[key]
+
+        ns = ctx.namespace(:opentelemetry)
+        return true if ns.empty? # restores original behavior so that keys are returned if tracing is not set in context.
+        return false unless ns.key?(key) && ns[key]
+
+        return true
+      end
+
+      def attributes_for(key, data)
+        attributes = {}
+        case key
+        when 'execute_query'
+          attributes['selected_operation_name'] = data[:query].selected_operation_name if data[:query].selected_operation_name
+          attributes['selected_operation_type'] = data[:query].selected_operation.operation_type
+          attributes['query_string'] = data[:query].query_string
+        end
+        attributes
+      end
+
+      def cached_platform_key(ctx, key, trace_phase)
+        cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
+
+        cache.fetch(key) do
+          cache[key] = if trace_phase == :field
+            return unless platform_key_enabled?(ctx, :enable_platform_field)
+
+            yield
+          elsif trace_phase == :authorized
+            return unless platform_key_enabled?(ctx, :enable_platform_authorized)
+
+            yield
+          elsif trace_phase == :resolve_type
+            return unless platform_key_enabled?(ctx, :enable_platform_resolve_type)
+
+            yield
+          else
+            raise "Unknown trace phase"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/platform_tracing.rb

@@ -10,6 +10,10 @@ module GraphQL
     class PlatformTracing
       class << self
         attr_accessor :platform_keys
+
+        def inherited(child_class)
+          child_class.platform_keys = self.platform_keys
+        end
       end
 
       def initialize(options = {})
@@ -41,7 +45,7 @@ module GraphQL
 
             platform_key = if trace_field
               context = data.fetch(:query).context
-              cached_platform_key(context, field) { platform_field_key(data[:owner], field) }
+              cached_platform_key(context, field, :field) { platform_field_key(data[:owner], field) }
             else
               nil
             end
@@ -57,14 +61,14 @@ module GraphQL
         when "authorized", "authorized_lazy"
           type = data.fetch(:type)
           context = data.fetch(:context)
-          platform_key = cached_platform_key(context, type) { platform_authorized_key(type) }
+          platform_key = cached_platform_key(context, type, :authorized) { platform_authorized_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
         when "resolve_type", "resolve_type_lazy"
           type = data.fetch(:type)
           context = data.fetch(:context)
-          platform_key = cached_platform_key(context, type) { platform_resolve_type_key(type) }
+          platform_key = cached_platform_key(context, type, :resolve_type) { platform_resolve_type_key(type) }
           platform_trace(platform_key, key, data) do
             yield
           end
@@ -135,7 +139,7 @@ module GraphQL
       # If the key isn't present, the given block is called and the result is cached for `key`.
       #
       # @return [String]
-      def cached_platform_key(ctx, key)
+      def cached_platform_key(ctx, key, trace_phase)
         cache = ctx.namespace(self.class)[:platform_key_cache] ||= {}
         cache.fetch(key) { cache[key] = yield }
       end

data/lib/graphql/tracing.rb

@@ -9,6 +9,7 @@ require "graphql/tracing/scout_tracing"
 require "graphql/tracing/skylight_tracing"
 require "graphql/tracing/statsd_tracing"
 require "graphql/tracing/prometheus_tracing"
+require "graphql/tracing/opentelemetry_tracing"
 
 if defined?(PrometheusExporter::Server)
   require "graphql/tracing/prometheus_tracing/graphql_collector"

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.13.12"
+  VERSION = "1.13.13"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.13.12
+  version: 1.13.13
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-14 00:00:00.000000000 Z
+date: 2022-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -659,6 +659,7 @@ files:
 - lib/graphql/tracing/data_dog_tracing.rb
 - lib/graphql/tracing/new_relic_tracing.rb
 - lib/graphql/tracing/notifications_tracing.rb
+- lib/graphql/tracing/opentelemetry_tracing.rb
 - lib/graphql/tracing/platform_tracing.rb
 - lib/graphql/tracing/prometheus_tracing.rb
 - lib/graphql/tracing/prometheus_tracing/graphql_collector.rb