Apollo Router Changelogs

🚀 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.

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)

Granular license enforcement (PR #7917)

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

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

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.

🐛 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.

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.

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.

📚 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