Live Recorder

Record and replay the execution of your Linux program

Debugging a live production system can be pretty hairy. But what if you could record your program's execution as it fails and replay the recording offline?

Capture software failures ‘in the act’

Replay the recording and get instant visibility into what your program did and why

Debug the recording instead of the live program

Watch video

Program execution recording for Linux applications

Record program execution and generate a recording artifact

Capture all non-deterministic data (down to instruction level) and recreate your application’s entire memory and the register state - on demand and with minimal overhead.

Replay the recording file to analyze execution history

Debug the recording using Live Recorder’s integrated reverse-debugging tool: step backwards as well as forwards in the code to find the root cause of the problem.

Fix the bug and deploy in production

Fix the bug and commit it to your test system. When the test turns green, deploy the fix to your users.

Key facts

About the Undo technology

Live Recorder's underlying technology records non-deterministic data and recomputes deterministic data on-the-fly. Recreate your application’s entire memory and register state on demand, at any point in its execution, and with minimal overhead. And critically, you can see it all just as it happened during the original run – without needing to know in advance what you will want to look at.

It's not fancy logging

Simply logging everything that the program does would produce an unmanageable amount of data.

No kernel changes

We don’t require a particular kernel or any kernel modules to be loaded. The Undo Engine is compatible with most mainstream Linux distributions.

No special hardware

Our approach is not limited to systems with hardware tracing modules or performance counters.

Debug ordinary native code

Threads, signals, and shared memory and device interactions are all supported and recorded as non-deterministic events.

Compiler- and library-agnostic

We don’t require the application to be recompiled or linked against particular libraries.

Faster than you think

Without specialized technology, recording large applications would be slow and unusable. Undo aims for a slowdown factor better than 5x in most applications.

Capture the most challenging bugs that cannot be caught any other way

Record and replay program execution and quickly diagnose severe software failures in test or in production

Competitor comparison

Live Recorder vs traditional software reliability solutions

Static and dynamic analysis tools only find defects they were programmed to seek out; they also highlight too many false positives. Meanwhile, manual debugging is mostly based on guesswork and eats away developer-time. Live Recorder is the only solution that gives you data-driven insight into what your software really did before it failed. Live Recorder can capture intermittent, non-deterministic failures which cannot be tracked down in any other way.

Capabilities

Live Recorder

Logging, dumps, printf

Static & dynamic analysis

Reproduce every failure with 100% certainty (including intermittent & non-deterministic)

Collect failure data from customers with minimal disruption

Analyze every possible cause of failure

Remove false positives causes

Request a demo

Explore our solutions

Live Recorder enables software reliability solutions across all phases of the software lifecycle.

Undo helps the largest software companies resolve their most challenging software defects

Developing complex mission-critical applications? Resolving intermittent, non-deterministic software failures in these types of environments can be a real challenge. Learn how Undo’s technology can help.