apollographql/router v2.6.0 on GitHub

🚀 Features

[Subgraph Insights] Experimental Apollo Subgraph Fetch Histogram (PR #8013, PR #8045)

This change adds a new, experimental histogram to capture subgraph fetch duration for GraphOS. This will
eventually be used to power subgraph-level insights in Apollo Studio.

This can be toggled on using a new boolean config flag:

telemetry:
  apollo:
    experimental_subgraph_metrics: true

The new instrument is only sent to GraphOS and is not available in 3rd-party OTel export targets. It is not currently
customizable. Users requiring a customizable alternative can use the existing http.client.request.duration
instrument, which measures the same value.

By @rregitsky in #8013 and #8045

Redis cache metrics (PR #7920)

The router now provides Redis cache monitoring with new metrics that help track performance, errors, and resource usage.

Connection and performance metrics:

apollo.router.cache.redis.connections: Number of active Redis connections
apollo.router.cache.redis.command_queue_length: Commands waiting to be sent to Redis, indicates if Redis is keeping up with demand
apollo.router.cache.redis.commands_executed: Total number of Redis commands executed
apollo.router.cache.redis.redelivery_count: Commands retried due to connection issues
apollo.router.cache.redis.errors: Redis errors by type, to help diagnose authentication, network, and configuration problems

Experimental performance metrics:

experimental.apollo.router.cache.redis.network_latency_avg: Average network latency to Redis
experimental.apollo.router.cache.redis.latency_avg: Average Redis command execution time
experimental.apollo.router.cache.redis.request_size_avg: Average request payload size
experimental.apollo.router.cache.redis.response_size_avg: Average response payload size

Note

The experimental metrics may change in future versions as we improve the underlying Redis client integration.

You can configure how often metrics are collected using the metrics_interval setting:

supergraph:
  query_planning:
    cache:
      redis:
        urls: ["redis://localhost:6379"]
        ttl: "60s"
        metrics_interval: "1s"  # Collect metrics every second (default: 1s)

By @BrynCooke in #7920

Granular license enforcement (PR #7917)

The router license functionality now allows granular specification of features enabled to support current and future pricing plans.

By @DMallare in #7917

Additional Connector Custom Instrument Selectors (PR #8045)

This adds new custom instrument selectors for Connectors and enhances some existing selectors. The new selectors are:

supergraph_operation_name
- The supergraph's operation name
supergraph_operation_kind
- The supergraph's operation type (e.g. query, mutation, subscription)
request_context
- Takes the value of the given key on the request context
connector_on_response_error
- Returns true when the response does not meet the is_successful condition. Or, if that condition is not set,
  returns true when the response has a non-200 status code

These selectors were modified to add additional functionality:

connector_request_mapping_problems
- Adds a new boolean variant that will return true when a mapping problem exists on the request
connector_response_mapping_problems
- Adds a new boolean variant that will return true when a mapping problem exists on the response

By @rregitsky in #8045

Enable jemalloc on MacOS (PR #8046)

This PR enables the jemalloc allocator on MacOS by default, making it easier to do memory profiling. Previously, this was only done for Linux.

By @Velfi in #8046

🐛 Fixes

Entity caching: fix inconsistency in cache-control header handling (PR #7987)

When the Subgraph Entity Caching feature is in use, it determines the Cache-Control HTTP response header sent to supergraph clients based on those received from subgraph servers.
In this process, Apollo Router only emits the max-age directive and not s-maxage.
This PR fixes a bug where, for a query that involved a single subgraph fetch that was not already cached, the subgraph response’s Cache-Control header would be forwarded as-is.
Instead, it now goes through the same algorithm as other cases.

By @SimonSapin in #7987

Query planning errors with progressive override on interface implementations (PR #7929)

The router now correctly generates query plans when using progressive override (@override with labels) on types that implement interfaces within the same subgraph. Previously, the Rust query planner would fail to generate plans for these scenarios with the error "Was not able to find any options for {}: This shouldn't have happened.", while the JavaScript planner handled them correctly.

This fix resolves planning failures when your schema uses:

Interface implementations local to a subgraph
Progressive override directives on both the implementing type and its fields
Queries that traverse through the overridden interface implementations

The router will now successfully plan and execute queries that previously resulted in query planning errors.

By @TylerBloom in #7929

Reliably distinguish GraphQL errors and transport errors in subscriptions (PR #7901)

The Multipart HTTP protocol for GraphQL Subscriptions distinguishes between GraphQL-level errors and fatal transport-level errors. The router previously used a heuristic to determine if a given error was fatal or not, which could sometimes cause errors to be wrongly classified. For example, if a subgraph returned a GraphQL-level error for a subscription and then immediately ended the subscription, the router might propagate this as a fatal transport-level error.

This is now fixed. Fatal transport-level errors are tagged as such when they are constructed, so the router can reliably know how to serialize errors when sending them to the client.

By @goto-bus-stop in #7901

📚 Documentation

Update Documentation To Add DockerHub References

Now that we have a DockerHub account we have published the Runtime Container to that account.
This fix simply adds a reference to that to the documentation

By @jonathanrainer in #8054