class GraphQL::Tracing::DetailedTrace

@see Graphql::Dashboard GraphQL::Dashboard for viewing stored results
end
end
rand <= 0.000_1 # one in ten thousand
# Could call out to Flipper, etc
# Could use ‘query.context`, `query.selected_operation_name`, `query.query_string` here
def self.detailed_trace?(query)
# And implement this hook to tell it when to take a sample:
use GraphQL::Tracing::DetailedTrace, redis: Redis.new(…), limit: 100
# Add the sampler:
class MySchema < GraphQL::Schema
@example Adding the sampler to your schema
If you need to save traces indefinitely, you can download them from Perfetto after opening them there.
You can configure this database to retail all data (persistent) or to expire data according to your rules.
__Redis__: The sampler stores its results in a provided Redis database. Depending on your needs,
overriding the one in `context`.
When `MySchema.detailed_trace?(query)` returns `true`, a profiler-specific `trace_mode: …` will be used for the query,
`DetailedTrace` can make detailed profiles for a subset of production traffic.

def self.use(schema, trace_mode: :profile_sample, memory: false, redis: nil, limit: nil)

Parameters:
  • limit (Integer) -- A maximum number of profiles to store
  • redis (Redis) -- If provided, profiles will be stored in Redis for later review 
def self.use(schema, trace_mode: :profile_sample, memory: false, redis: nil, limit: nil)
  storage = if redis
    RedisBackend.new(redis: redis, limit: limit)
  elsif memory
    MemoryBackend.new(limit: limit)
  else
    raise ArgumentError, "Pass `redis: ...` to store traces in Redis for later review"
  end
  schema.detailed_trace = self.new(storage: storage, trace_mode: trace_mode)
  schema.trace_with(PerfettoTrace, mode: trace_mode, save_profile: true)
end

def delete_all_traces

Returns:
  • (void) - 
def delete_all_traces
  @storage.delete_all_traces
end

def delete_trace(id)

Returns:
  • (void) - 
def delete_trace(id)
  @storage.delete_trace(id)
end

def find_trace(id)

Returns:
  • (StoredTrace, nil) - 
def find_trace(id)
  @storage.find_trace(id)
end

def initialize(storage:, trace_mode:) 

def initialize(storage:, trace_mode:)
  @storage = storage
  @trace_mode = trace_mode
end

def save_trace(operation_name, duration_ms, begin_ms, trace_data)

Returns:
  • (String) - ID of saved trace 
def save_trace(operation_name, duration_ms, begin_ms, trace_data)
  @storage.save_trace(operation_name, duration_ms, begin_ms, trace_data)
end

def traces(last: nil, before: nil)

Returns:
  • (Enumerable) -

Parameters:
  • before (Integer) -- Timestamp in milliseconds since epoch
  • last (Integer) -- 
def traces(last: nil, before: nil)
  @storage.traces(last: last, before: before)
end