// ❌ Anonymous operation — all APM data aggregates under a single unlabeled bucket
// You cannot: alert on this operation's p95 latency, compare it over time,
// identify which team owns it, or safely deprecate fields it uses
const { data } = useQuery(gql`
  query {
    user(id: $id) {
      name
      orders { total }
    }
  }
`);

// ✅ Named operation — each operation is independently measurable and attributable
// Apollo Router, Apollo Studio, Datadog APM, Jaeger all key on operationName
const { data } = useQuery(gql`
  query GetUserWithOrders($id: ID!) {
    user(id: $id) {
      name
      orders { total }
    }
  }
`);

# router.yaml
telemetry:
  tracing:
    otlp:
      endpoint: http://otel-collector:4317
      protocol: grpc
    # Router automatically emits spans per:
    # - HTTP request (root span with operationName)
    # - Query planning (how long Router took to plan)
    # - Per-subgraph fetch (with subgraph name and URL)
    # - Entity resolution (per-@key entity lookup)
    propagation:
      request:
        header_name: "x-request-id"

// ✅ Resolver-level OTel spans with @opentelemetry/api
import { trace, SpanStatusCode } from '@opentelemetry/api';

const tracer = trace.getTracer('graphql-server');

const resolvers = {
  Query: {
    users: async (_, args, ctx) => {
      return tracer.startActiveSpan('Query.users', async (span) => {
        try {
          const users = await ctx.db.users.findAll(args);
          span.setAttributes({
            'graphql.field': 'Query.users',
            'db.rows_returned': users.length,
          });
          span.setStatus({ code: SpanStatusCode.OK });
          return users;
        } catch (err) {
          span.recordException(err as Error);
          span.setStatus({ code: SpanStatusCode.ERROR, message: (err as Error).message });
          throw err;
        } finally {
          span.end();
        }
      });
    },
  },
};

Client → Router (sets x-request-id: uuid) → Users Subgraph (receives x-request-id) → DB
                                            → Orders Subgraph (receives x-request-id) → DB

// ✅ Emit DataLoader batch size as a metric for N+1 detection
import { metrics } from '@opentelemetry/api';

const meter = metrics.getMeter('graphql-server');
const batchSizeHistogram = meter.createHistogram('dataloader.batch_size', {
  description: 'Number of keys batched per DataLoader invocation',
});

async function batchLoadOrders(userIds: readonly string[]): Promise<Order[][]> {
  // Record the batch size on every DataLoader invocation
  // If you see batchSize: 1 in production, the N+1 is not resolved
  batchSizeHistogram.record(userIds.length, { loader: 'ordersLoader' });
  return ctx.db.orders.findByUserIds(userIds);
}

# Count field usage across all incoming operation documents
npx graphql-inspector field-usage \
  --schema schema.graphql \
  --documents operations/*.graphql

# Output:
# User.email: 847 usages across 12 operations (last used: 2026-09-11)
# User.legacyId: 0 usages across 0 operations (deprecated — safe to remove)

📊 Field Insights: User.legacyId
  Status: @deprecated
  Last requested: 2026-07-15 (89 days ago)
  Request count (last 30d): 0
  GraphOS signal: ✅ Safe to remove

// ✅ The N+1 detection trace signature (DataLoader working correctly):
// Root span: GetUserWithOrders [operationName]
//   -> Query.users [resolver span] — 1 DB query, 50 rows
//   -> ordersLoader [DataLoader span] — batchSize: 50, 1 DB query
//      WHERE user_id IN (1, 2, 3, ..., 50)

// ❌ The N+1 detection trace signature (DataLoader NOT batching):
// Root span: GetUserWithOrders
//   -> Query.users — 1 DB query, 50 rows
//   -> ordersLoader — batchSize: 1   (N+1 signature)
//   -> ordersLoader — batchSize: 1
//   -> ordersLoader — batchSize: 1
//   ...   (50 more)