Rails Hackathon 2022 Winner
What's does an hour of downtime cost you?
(use our calculator to find out)
Decode even the most convoluted Ruby on Rails production incidents with our debugger's powerful visualization, guiding you through the labyrinth of call chains and data flow.
Rails Hackathon 2022 Winner
Instantly see in production every method call, parameter and return value, for a given request.
You have hundreds, thousands, millions of lines of code to deal with.
For every bug, there's only a few hundred lines that are relevant.
Stop using the Rails console to debug critical issues. Fix your outage in minutes, not hours.
When there's a production incident, your first inclination is to look at the code that was changed in the last few days. But old pull requests won't reveal everything.
You need to look at program flow issues - e.g. a method is called via a callback on the application controller, but then there's a redundant call within one of the controller actions.
Or maybe there's an action taken based on a function five levels up the chain - e.g. if the value of a parameter comes from a database value or is calculated far up the call chain, it's really hard to trace that parameter to its originating source and determine if it's a valid value being passed in.
Reconstructing code paths 5 levels deep from the Rails console is a nightmare. When you're under pressure, losing revenue with every down minute, the pressure builds quickly.
Each call graph is an image. Embed those images within your Jira tickets, your Slack channels, PagerDuty comments so that all on-call engineers can quickly visual the call chain.
If you have a new engineer, they're on-call, and a production incident occurs, you want to get them up to speed as quickly as possible.
You can't expect any engineer that is tackling a tough production bug to navigate 300,000 lines of code.
The issue with standard debuggers, code navigation (e.g Rubymine), the Rails console or just randomly sprinkling puts statements everywhere, is that you're only getting a sample of the execution. Wherever you place your breakpoint, that's your visibility.
Call Stacking is broader, an unbiased profiler that allows you to envision the entire call stack, without any sort of manual intervention/breakpoints. Call Stacking passively collects all of the important methods, their context, and presents them to your engineer in an easily digestible visual.
The visualization is built automatically for you, without any intervention.
Pricing plans for all levels.
White Glove Support (all inclusive)
Will help with:
Yes. It's impossible to capture the full context of an app - method calls, parameter values, return values, without adding some additional overhead per request.
Tracing is added and then removed on a per request basis using an
around_action in your
HTTP request times may have to be extended depending on the size of the codebase.
Once the instrumented methods are removed for the request, all subsequent requests for that server will be called with the original implementation.
Only the instrumented requests will incur the overhead of tracing.