🤖 Meet OnCall AI, our observability copilot that makes troubleshooting easy. Read announcement.

Skip to content

How Can Distributed Tracing Solve N+1 Query Problem? (A Comprehensive Guide)

Jun 14, 2024 / 9 minute read

Learn how distributed tracing can solve N+1 query problems in this guide. Discover 4 steps to solve this issue to improve app response time and performance.


N+1 queries are a performance issue in which an application queries databases in a loop. They occur when an app queries a database to retrieve an object. However, for each object retrieved, it searches for related objects. Since every database connection takes time, N+1 queries are slower than a single one. Fortunately, distributed tracing can solve this issue.

Distributed tracing is the process of observing data requests as they flow through a distributed system. With this feature enabled, you can identify long-running traces. It also helps you identify the calling patterns behind slow requests.

While the N+1 query problem seems trivial, it can cause network overhead, impacting app and database performance. Thus, solving this issue as soon as possible is crucial. This article provides an in-depth guide on how distributed tracing can solve the N+1 query problem.

Key Takeaways

  • N+1 query problem is a performance anti-pattern. It happens when an application spams the database with plenty of queries rather than a single query to fetch all the needed data.

  • While numerous ways exist to solve N+1 query issues, distributed tracing offers an effective solution.

  • With distributed tracing, you can leverage traces to detect query patterns. This data helps you find inefficient and spam queries that only retrieve related objects.

  • Besides detecting N+1 query patterns, distributed tracing also helps optimize and monitor the queries to see if the efforts were effective.

  • Leveraging distributed tracing can help resolve N+1 query, preventing further overheads and improving application performance and query efficiency.

Complete Guide on Solving N+1 Problem with Distributed Tracing

The N+1 query problem happens when an app retrieves an object or a collection of objects from a database. Then, it creates an extra query for each object's related data. In this sense, the first query is N, and the extra query is N+1. Hence, the problem's name N+1 queries.

Inefficient use of ORMs is the usual cause of N+1 query problems.

Such issues are typical with object-relational mapping (ORM) frameworks. ORMs offer an abstraction space between programming languages and relational database management systems.

With ORMs, developers interact with the database using specific programming language objects. The framework then uses these objects to automate queries. However, the automation can lead to N+1 queries, which causes network overheads. Such an issue happens especially to frameworks with complex database schemas.

Due to ORM's simple framework for data accessibility, it automates query generation. While this has some positive effects, it can also cause inefficient data usage.

N+1 query problems usually arise in web frameworks like Django and Ruby on Rails. They usually happen when ORMs use nested loops to iterate over the query results. Then, the frameworks retrieve the related data in the inner loop. Thus, it usually leads to the outer loop executing multiple queries.

How Can Distributed Tracing Solve N1 Query Problems?

If you’re unfamiliar with how distributed tracing works, it’s the process of tracking requests moving through different parts of a system. It gives each request a unique tag, allowing users to follow it easily. In this way, businesses can monitor their processes in real time and find problems as they arise.

With the unique tags, you can identify repetitive patterns, a sign of N+1 queries. This tracing provides comprehensive context, allowing you to find which queries are inefficient and spam.

By leveraging distributed tracing, you can easily detect N+1 queries, optimize them and ensure they remain effective, and prevent them from causing overheads.

Steps on How to Solve N+1 Problem with Distributed Tracing

Leveraging distributed tracing to solve the N+1 problem is ideal if you use web frameworks with ORMs. You’ll only need your choice of tracing instrumentation, and that’s only if you don’t have one yet. Besides the tracing instrumentation, you might want to use monitoring or anomaly detection tools.

Here are four main steps in solving N+1 query problems using distributed tracing:

Step 1: Integrate Tracing Instrumentation in the Application.

Using effective instrumentation is crucial for effectively distributed tracing. In this process, you should do the following:

Select your preferred tracing library.

When doing so, always check if your chosen library supports distributed tracing. Some of the popular libraries that support this tracing are:

  • OpenTelemetry

  • Grafana

  • Dynatrace

  • SigNoz

  • Jaeger

The demonstrations and examples below will use OpenTelemetry, but you can use any.

Add tracing hooks.

Add tracing hooks to your application's code once you have the library. For instance, if you're using an app based on Node.js, use the following code to add OpenTelemetry:

const { NodeTracerProvider } = require('@opentelemetry/node');
const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
const { ConsoleSpanExporter } = require('@opentelemetry/tracing');

const provider = new NodeTracerProvider();
provider.addSpanProcessor(new SimpleSpanProcessor(new ConsoleSpanExporter()));

Instrument all database calls.

Once you install a tracing library, you can trace all database calls. This process can involve covering your database client. You can also use a third-party application to trace.

Verify the instrumentation.

Once done, confirm that the tool generates and collects the traces.

Confirm that traces are being generated and collected by your tracing backend.

Step 2: Identify N+1 Query Problems in Your Application.

With distributed tracing enabled, you can begin detecting N+1 query problems in your app. This step involves the following processes:

Analyzing traces

With your preferred tracing instrumentation, collect and analyze your application's traces. N+1 problems have patterns of a single request, leading to spam of the same database queries.

Leveraging graphical representations

Most tracing tools offer graphical capabilities to visualize query patterns. For instance, tools like Zipkin and Jaeger offer visualizations that emphasize query timing and sequence. Leveraging these features can help you quickly detect N+1 issue patterns.

Detecting anomalies

Besides traces and graphs, you can also use anomaly detection techniques. Most anomaly detection tools can flag N+1 query issues with thresholds and triggers.

For instance, you can set thresholds for query counts and execution times. When exceeded, these thresholds trigger alerts, notifying you or automating further investigation.

Step 3: Optimize Queries to Prevent N+1 Query Issues.

Successfully detecting N+1 queries should not be the end. Once found, you should optimize these queries to prevent them from spamming again.

Here are several methods to do this step:

Using Batch Query Requests

Grouping several queries into a single batch request can reduce database calls. For instance, instead of retrieving user details individually, you can get them all using a single query.

Here's an example code:

  SELECT * FROM users WHERE id IN (1, 2, 3, 4);

Comparative performance graphs before and after batching can highlight the efficiency gain.

Utilizing Caching Mechanisms

Caching is a mechanism that stores frequently accessed data. By leveraging caches, you can reduce the need to retrieve repetitive objects.


You can integrate third-party tools like Redis to cache your query results. To measure the cache's effectiveness, you can check hit rates before and after implementation.

Implementing Data Loaders

A data loader is a client app for bulk data importing or exporting. With this tool, you can batch and cache requests better.

Here's an example of how to use the DataLoader library in a Node.js environment:

  const DataLoader = require('dataloader');
  const userLoader = new DataLoader(async (keys) => {
    const users = await getUsersByIds(keys); // Batch function
    return keys.map(key => users.find(user => user.id === key));

  // Usage
  userLoader.load(1).then(user => console.log(user));


You can measure improvements by comparing metrics before and after implementing data loaders.

Step 4: Validate Improvements Made Using Distributed Tracing.

After all the optimizations, it's crucial to ensure their effectiveness. To do so, you must continue monitoring and analyzing your app's performance metrics.

Here are some processes you can do to achieve this step:

Monitoring Performance Metrics

Performance metrics show essential data about your app. Thus, it includes your query execution time, database loading, and response time.


Tools like Edge Delta can help support real-time monitoring. Edge Delta offers real-time monitoring, instantly processing data within the agent for better insights. It's an observability platform that collects data, such as logs and metrics, and displays it in one place. This way, you can view all data for easy troubleshooting. It also uses a machine learning pattern to make the data usable for analysis.

Analyzing Tracing Data After Optimization

Analysis of traces after optimizing the query helps verify improvements. It's best to compare traces before and after optimization. This way, you can confirm if you have seen fewer queries and if it improved the execution times.


While N+1 query problems seem trivial, if left unchecked, they can hurt your applications' performance and scalability. The inefficiency of these query patterns causes network overheads, latencies, high server loads, and more.

Distributed tracing offers an effective solution to this issue by helping in detecting query patterns. With this feature, you can find and optimize inefficient and spam queries.

With distributed tracing, you can also ensure that the optimization works well. The only thing to do is to continuously monitor your tracing instruments and the queries to avoid such issues again.


How to solve n-1 problem in GraphQL?

The N+1 problem in GraphQL can be addressed using a data loader. With these tools, you can reduce the number of calls made by GraphQL APIs for additional data. It also replaces the app’s datafetchers.

How to detect n-1 problem?

N+1 queries are detectable using logs and database tools. You can find repetitive or spam queries searching for related objects with these sources.

What is the N 1 query pattern?

The N+1 query is an anti-pattern stemming from the leaky abstraction provided by ORMs. Due to the ORMs nature of simplifying data access, it autogenerates unnecessary queries instead of using only a single one.


Stay in Touch

Sign up for our newsletter to be the first to know about new articles.