graphql 2.5.18 → 2.5.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3512540a3ee54e940cc015c0bd3931895b376d8c01550e8c1aedc2244937dd54
-  data.tar.gz: d988a0eeca9a38d914a0def3409e8dc89025420de492a632bc5a63a8203d89d2
+  metadata.gz: 3a94d75c592000805bf9fd18507343c0b3428f1cf1d9a1828edc921828fd2735
+  data.tar.gz: 2984583eb702965d43e45f58f1ac29b6a782b8ecf02b4ee1953b5c5bbb6ec872
 SHA512:
-  metadata.gz: 4ab540f193797624203186b0008a05fbfcea52975b6cf9cd078a4a1f275c076526b2ac76fedcd281164fe199a1dee82800636f23ce2f998a8d1a61d623c1c6c0
-  data.tar.gz: fd5a869314ee4a8cf3d6b0019bc1f91908a03425f5c8a6d1618e8a6f95570782a59d014a048a4f526a7e15539d5179db2c5e78c1fd0a79aef7f2104d5532db23
+  metadata.gz: 743bd603f22bb38bdff984c75b37eea32d460aeafd50617fc52dc9c4b93fe1d3265df196b728432a7b2d6494a6ba20c47b658ee84b387377037ea173844c654b
+  data.tar.gz: 12354210f6208443a5ec0dc931606440de29bfe0bdb7c6468e7faf9bc013a67671eab62fcc3bd88405d1ffb840a5c0e04be337d9a6707d511a2046d315722f63

data/lib/generators/graphql/detailed_trace_generator.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require 'rails/generators/active_record'
+
+module Graphql
+  module Generators
+    class DetailedTraceGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+      desc "Install GraphQL::Tracing::DetailedTrace for your schema"
+      source_root File.expand_path('../templates', __FILE__)
+
+      class_option :redis,
+        type: :boolean,
+        default: false,
+        desc: "Use Redis for persistence instead of ActiveRecord"
+
+      def self.next_migration_number(dirname)
+        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def install_detailed_traces
+
+        schema_glob = File.expand_path("app/graphql/*_schema.rb", destination_root)
+        schema_file = Dir.glob(schema_glob).first
+        if !schema_file
+          raise ArgumentError, "Failed to find schema definition file (checked: #{schema_glob.inspect})"
+        end
+        schema_file_match = /( *)class ([A-Za-z:]+) < GraphQL::Schema/.match(File.read(schema_file))
+        schema_name = schema_file_match[2]
+        indent = schema_file_match[1] + "  "
+
+        if !options.redis?
+          migration_template 'create_graphql_detailed_traces.erb', 'db/migrate/create_graphql_detailed_traces.rb'
+        end
+
+        log :add_detailed_traces_plugin
+        sentinel = /< GraphQL::Schema\s*\n/m
+        code = <<-RUBY
+#{indent}use GraphQL::Tracing::DetailedTrace#{options.redis? ? ", redis: raise(\"TODO: pass a connection to a persistent redis database\")" : ""}, limit: 50
+
+#{indent}# When this returns true, DetailedTrace will trace the query
+#{indent}# Could use `query.context`, `query.selected_operation_name`, `query.query_string` here
+#{indent}# Could call out to Flipper, etc
+#{indent}def self.detailed_trace?(query)
+#{indent}  rand <= 0.000_1 # one in ten thousand
+#{indent}end
+
+        RUBY
+
+        in_root do
+          inject_into_file schema_file, code, after: sentinel, force: false
+        end
+
+        routes_source = File.read(File.expand_path("config/routes.rb", destination_root))
+        already_has_dashboard = routes_source.include?("GraphQL::Dashboard") ||
+          routes_source.include?("Schema.dashboard") ||
+          routes_source.include?("GraphQL::Pro::Routes::Lazy")
+
+        if (!already_has_dashboard || behavior == :revoke)
+          log :route, "GraphQL::Dashboard"
+          shell.mute do
+            route <<~RUBY
+            # TODO: add authorization to this route and expose it in production
+            # See https://graphql-ruby.org/pro/dashboard.html#authorizing-the-dashboard
+            if Rails.env.development?
+              mount GraphQL::Dashboard, at: "/graphql/dashboard", schema: #{schema_name.inspect}
+            end
+
+            RUBY
+          end
+
+          gem("google-protobuf")
+
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql/templates/create_graphql_detailed_traces.erb

@@ -0,0 +1,10 @@
+class CreateGraphqlDetailedTraces < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :graphql_detailed_traces, force: true do |t|
+      t.bigint :begin_ms, null: false
+      t.float :duration_ms, null: false
+      t.binary :trace_data, null: false
+      t.string :operation_name, null: false
+    end
+  end
+end

data/lib/graphql/dashboard.rb

@@ -120,7 +120,7 @@ module Graphql
     end
 
     class StaticsController < ApplicationController
-      skip_after_action :verify_same_origin_request
+      skip_forgery_protection
       # Use an explicit list of files to avoid any chance of reading other files from disk
       STATICS = {}
 

data/lib/graphql/tracing/detailed_trace/active_record_backend.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      class ActiveRecordBackend
+        class GraphqlDetailedTrace < ActiveRecord::Base
+        end
+
+        def initialize(limit: nil, model_class: nil)
+          @limit = limit
+          @model_class = model_class || GraphqlDetailedTrace
+        end
+
+        def traces(last:, before:)
+          gdts = @model_class.all.order("begin_ms DESC")
+          if before
+            gdts = gdts.where("begin_ms < ?", before)
+          end
+          if last
+            gdts = gdts.limit(last)
+          end
+          gdts.map { |gdt| record_to_stored_trace(gdt) }
+        end
+
+        def delete_trace(id)
+          @model_class.where(id: id).destroy_all
+          nil
+        end
+
+        def delete_all_traces
+          @model_class.all.destroy_all
+        end
+
+        def find_trace(id)
+          gdt = @model_class.find_by(id: id)
+          if gdt
+            record_to_stored_trace(gdt)
+          else
+            nil
+          end
+        end
+
+        def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+          gdt = @model_class.create!(
+            begin_ms: begin_ms,
+            operation_name: operation_name,
+            duration_ms: duration_ms,
+            trace_data: trace_data,
+          )
+          if @limit
+            @model_class
+              .where("id NOT IN(SELECT id FROM graphql_detailed_traces ORDER BY begin_ms DESC LIMIT ?)", @limit)
+              .delete_all
+          end
+          gdt.id
+        end
+
+        private
+
+        def record_to_stored_trace(gdt)
+          StoredTrace.new(
+            id: gdt.id,
+            begin_ms: gdt.begin_ms,
+            operation_name: gdt.operation_name,
+            duration_ms: gdt.duration_ms,
+            trace_data: gdt.trace_data
+          )
+
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/detailed_trace.rb

@@ -1,10 +1,13 @@
 # frozen_string_literal: true
+if defined?(ActiveRecord)
+  require "graphql/tracing/detailed_trace/active_record_backend"
+end
 require "graphql/tracing/detailed_trace/memory_backend"
 require "graphql/tracing/detailed_trace/redis_backend"
 
 module GraphQL
   module Tracing
-    # `DetailedTrace` can make detailed profiles for a subset of production traffic.
+    # `DetailedTrace` can make detailed profiles for a subset of production traffic. Install it in Rails with `rails generate graphql:detailed_trace`.
     #
     # When `MySchema.detailed_trace?(query)` returns `true`, a profiler-specific `trace_mode: ...` will be used for the query,
     # overriding the one in `context[:trace_mode]`.
@@ -13,10 +16,19 @@ module GraphQL
     # this behavior by extending {DetailedTrace} and overriding {#inspect_object}. You can opt out of debug annotations
     # entirely with `use ..., debug: false` or for a single query with `context: { detailed_trace_debug: false }`.
     #
-    # __Redis__: The sampler stores its results in a provided Redis database. Depending on your needs,
-    # You can configure this database to retain all data (persistent) or to expire data according to your rules.
+    # You can store saved traces in two ways:
+    #
+    # - __ActiveRecord__: With `rails generate graphql:detailed_trace`, a new migration will be added to your app.
+    # That table will be used to store trace data.
+    #
+    # - __Redis__: Pass `redis: ...` to save trace data to a Redis database. Depending on your needs,
+    # you can configure this database to retain all data (persistent) or to expire data according to your rules.
+    #
     # If you need to save traces indefinitely, you can download them from Perfetto after opening them there.
     #
+    # @example Installing with Rails
+    #   rails generate graphql:detailed_trace # optional: --redis
+    #
     # @example Adding the sampler to your schema
     #   class MySchema < GraphQL::Schema
     #     # Add the sampler:
@@ -53,13 +65,16 @@ module GraphQL
       # @param redis [Redis] If provided, profiles will be stored in Redis for later review
       # @param limit [Integer] A maximum number of profiles to store
       # @param debug [Boolean] if `false`, it won't create `debug` annotations in Perfetto traces (reduces overhead)
-      def self.use(schema, trace_mode: :profile_sample, memory: false, debug: debug?, redis: nil, limit: nil)
+      # @param model_class [Class<ActiveRecord::Base>] Overrides {ActiveRecordBackend::GraphqlDetailedTrace} if present
+      def self.use(schema, trace_mode: :profile_sample, memory: false, debug: debug?, redis: nil, limit: nil, model_class: nil)
         storage = if redis
           RedisBackend.new(redis: redis, limit: limit)
         elsif memory
           MemoryBackend.new(limit: limit)
+        elsif defined?(ActiveRecord)
+          ActiveRecordBackend.new(limit: limit, model_class: model_class)
         else
-          raise ArgumentError, "Pass `redis: ...` to store traces in Redis for later review"
+          raise ArgumentError, "To store traces, install ActiveRecord or provide `redis: ...`"
         end
         detailed_trace = self.new(storage: storage, trace_mode: trace_mode, debug: debug)
         schema.detailed_trace = detailed_trace

data/lib/graphql/tracing/perfetto_trace.rb

@@ -91,6 +91,21 @@ module GraphQL
           ctx_debug
         end
 
+        @arguments_filter = if (ctx = query&.context) && (dtf = ctx[:detailed_trace_filter])
+          dtf
+        elsif defined?(ActiveSupport::ParameterFilter)
+          fp = if defined?(Rails) && Rails.application && (app_config = Rails.application.config.filter_parameters).present? && !app_config.empty?
+            app_config
+          elsif ActiveSupport.respond_to?(:filter_parameters)
+            ActiveSupport.filter_parameters
+          else
+            EmptyObjects::EMPTY_ARRAY
+          end
+          ActiveSupport::ParameterFilter.new(fp, mask: ArgumentsFilter::FILTERED)
+        else
+          ArgumentsFilter.new
+        end
+
         Fiber[:graphql_flow_stack] = nil
         @sequence_id = object_id
         @pid = Process.pid
@@ -590,6 +605,22 @@ module GraphQL
         Fiber.current.object_id
       end
 
+      class ArgumentsFilter
+        # From Rails defaults
+        # https://github.com/rails/rails/blob/main/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb.tt#L6-L8
+        SENSITIVE_KEY = /passw|token|crypt|email|_key|salt|certificate|secret|ssn|cvv|cvc|otp/i
+        FILTERED = "[FILTERED]"
+
+        def filter_param(key, value)
+          if (key.is_a?(String) && SENSITIVE_KEY.match?(key)) ||
+                  (key.is_a?(Symbol) && SENSITIVE_KEY.match?(key.name))
+            FILTERED
+          else
+            value
+          end
+        end
+      end
+
       def debug_annotation(iid, value_key, value)
         if iid
           DebugAnnotation.new(name_iid: iid, value_key => value)
@@ -634,7 +665,22 @@ module GraphQL
         when Array
           debug_annotation(iid, :array_values, v.each_with_index.map { |v2, idx| payload_to_debug((k ? "#{k}.#{idx}" : String(idx)), v2, intern_value: intern_value) }.compact)
         when Hash
-          debug_annotation(iid, :dict_entries, v.map { |k2, v2| payload_to_debug(k2, v2, intern_value: intern_value) }.compact)
+          debug_v = v.map { |k2, v2|
+            debug_k = case k2
+            when String
+              k2
+            when Symbol
+              k2.name
+            else
+              String(k2)
+            end
+            filtered_v2 = @arguments_filter.filter_param(debug_k, v2)
+            payload_to_debug(debug_k, filtered_v2, intern_value: intern_value)
+          }
+          debug_v.compact!
+          debug_annotation(iid, :dict_entries, debug_v)
+        when GraphQL::Schema::InputObject
+          payload_to_debug(k, v.to_h, iid: iid, intern_value: intern_value)
         else
           class_name_iid = @interned_da_string_values[v.class.name]
           da = [

data/lib/graphql/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.18
+  version: 2.5.19
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-01-22 00:00:00.000000000 Z
+date: 2026-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -383,6 +383,7 @@ files:
 - ".yardopts"
 - MIT-LICENSE
 - lib/generators/graphql/core.rb
+- lib/generators/graphql/detailed_trace_generator.rb
 - lib/generators/graphql/enum_generator.rb
 - lib/generators/graphql/field_extractor.rb
 - lib/generators/graphql/input_generator.rb
@@ -412,6 +413,7 @@ files:
 - lib/generators/graphql/templates/base_resolver.erb
 - lib/generators/graphql/templates/base_scalar.erb
 - lib/generators/graphql/templates/base_union.erb
+- lib/generators/graphql/templates/create_graphql_detailed_traces.erb
 - lib/generators/graphql/templates/enum.erb
 - lib/generators/graphql/templates/graphql_controller.erb
 - lib/generators/graphql/templates/input.erb
@@ -741,6 +743,7 @@ files:
 - lib/graphql/tracing/data_dog_trace.rb
 - lib/graphql/tracing/data_dog_tracing.rb
 - lib/graphql/tracing/detailed_trace.rb
+- lib/graphql/tracing/detailed_trace/active_record_backend.rb
 - lib/graphql/tracing/detailed_trace/memory_backend.rb
 - lib/graphql/tracing/detailed_trace/redis_backend.rb
 - lib/graphql/tracing/legacy_hooks_trace.rb