Observability at scale is challenging—especially when dealing with high-volume distributed traces. Traditional tracing tools struggle with large traces containing thousands of spans, often leading to sluggish UIs and an unmanageable debugging experience. Most tracing tools we checked have a limit on the maximum spans they can load for a single trace.
But with SigNoz, we’ve redefined what’s possible.
SigNoz is now the only distributed tracing tool capable of loading a million spans seamlessly.
With our latest improvements, users can navigate, analyze, and debug even the largest traces effortlessly. Whether you’re operating a high-frequency trading system, debugging background jobs, or optimizing game performance, SigNoz delivers an unmatched tracing experience that scales with your needs.
We have also shipped a completely revamped UI for the Trace Details page to make debugging more effortless than ever.
Watch the demo
Check out this video to see our new Trace Details page in action.
The Need for Massive Trace Handling
Modern distributed applications generate massive amounts of trace data. In industries like finance, gaming, and large-scale microservices architectures, certain background processes or high-volume tasks result in traces containing hundreds of thousands of spans. Until now, tracing tools struggled to handle such scale effectively, often leading to:
- Unresponsive UIs when loading large traces.
- Laggy interactions while navigating through spans.
- Browser crashes while loading large traces
- Limited visibility, making it hard to pinpoint bottlenecks.
With SigNoz’s new Trace Details Page, we have solved these pain points with a fast, scalable, and intuitive UI that supports 1 million spans per trace.
How SigNoz Handles a Million Spans with Ease
Unlike traditional tracing tools that struggle with scale, we used smart engineering techniques to keep the UI smooth and responsive.
1. Dynamic Span Loading Without Preloading
Instead of overloading your browser by preloading massive amounts of data, we intelligently fetch only the required spans on demand. This allows:
- Seamless navigation without overloading memory.
- Fast trace rendering, even with 1 million spans.
- An intuitive, lag-free debugging experience.
2. Smart Search & Filtering to Find Spans Instantly
When dealing with 100k+ spans, scrolling through them manually isn’t feasible. That’s why we introduced powerful search and filtering capabilities:
- Jump directly to a span by span ID, attribute, or error state.
- Quickly find bottlenecks by filtering spans with high latency or specific errors.
3. Synchronized Flame Graph & Waterfall Views
SigNoz ensures that both flame graphs and waterfall models stay perfectly in sync, so users always see:
- Where each span fits in the overall trace timeline.
- The impact of specific spans on the full trace.
4. Browser-Friendly Performance Optimization
Handling millions of spans isn’t just about fetching the data efficiently. We optimized trace rendering for browser performance by:
- Chunking data into smaller batches to avoid UI freezing.
- Maintaining a responsive JavaScript thread so the interface remains smooth.
- Lazy-loading spans dynamically to prevent unnecessary processing.
Where This Feature Makes the Biggest Impact
The ability to load unlimited spans can benefit any application that involves a lot of processes for a single transaction.
Some industries where this is particularly impactful include finance apps, gaming applications and any application that involves a lot of background job processing.
Debugging with Traces in Finance Applications
Financial applications, especially in high-frequency trading (HFT) and real-time market analytics, generate massive traces because of the sheer volume of transactions and interactions happening in milliseconds. Each trade execution, order book update, and pricing request results in multiple spans as requests travel through microservices, databases, and external APIs. A single trade might involve thousands of spans due to rapid order matching, risk evaluation, and settlement processes occurring in parallel.
In such environments, every microsecond matters, and SigNoz’s ability to handle unlimited spans per trace provides an unparalleled advantage by allowing teams to analyze transaction latencies by quickly identifying the responsible spans.
Debugging with Traces in Gaming Applications
The gaming industry relies on ultra-low latency and high data throughput to ensure a smooth, real-time player experience. Multiplayer online games, real-time physics engines, and game matchmaking systems generate massive amounts of trace data due to the high number of interactions occurring every second. A single game session can produce thousands of spans tracking player movements, network latency, physics calculations, and server interactions.
With SigNoz’s ability to handle unlimited spans, gaming platforms can:
- Monitor network latencies to ensure low ping rates and responsive gameplay.
- Optimize game server performance by analyzing lag spikes and backend bottlenecks.
- Track real-time interactions to detect issues in matchmaking or session stability.
By leveraging advanced tracing capabilities, game developers can fine-tune their infrastructure, enhance player experience, and reduce in-game performance issues like lag and stuttering.
How This Feature Benefits Background Job Processing
Many modern applications rely on background processes to handle asynchronous tasks such as data processing, bulk updates, scheduled jobs, and message queue processing. These tasks often generate massive traces because each job spawns thousands of subtasks, leading to a complex execution chain.
For example, in an e-commerce platform, a background job may:
- Process order fulfillment, updating inventory, payments, and shipping details.
- Generate and send personalized notifications to thousands of users.
- Index new product data for search and recommendation engines.
With SigNoz’s ability to show and analyze unlimited spans in a single trace, engineering teams can:
- Identify slow-running tasks in bulk processing pipelines.
- Monitor execution dependencies between multiple async jobs.
- Optimize queue-based workflows by spotting bottlenecks in worker performance.
By providing deep visibility into background jobs, SigNoz ensures that critical backend operations run efficiently and at scale, reducing delays and improving system responsiveness.
What’s Next? Upcoming Enhancements
This is just the beginning. Our roadmap includes:
- Span Event Visualization: Showing key trace events on a timeline for better analysis.
- Span Links: Linking spans across traces to visualize complex async workflows.
- Advanced Analytics: P90/P99 latency breakdowns for detailed performance insights.
Ready to Experience Limitless Tracing?
SigNoz is pushing the boundaries of distributed tracing. It’s the only open-source observability tool to support traces with unlimited spans.
If you’re working with large-scale traces, try out our new Trace Details Page today and experience the smoothest debugging workflow ever.
For setup instructions and more details, check out our documentation.
Have feedback? Join our Slack Community and let us know what you think!
SigNoz is redefining what’s possible in tracing. Now, you don’t have to worry about limits—because with SigNoz, there are none. 🚀
