Live Recorder

Record and replay the execution of your software

Debugging intermittent failures - whether in development, test or in production - takes time. It slows down development projects and frustrates customers... What if you could record your program's execution as it fails and replay the recording offline any time anywhere?

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

Record

Record Linux programming errors

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

Engineers can then rewind and replay the recording file to analyze execution history. Using Live Recorder's integrated reversible debugger (UndoDB), engineers can step backwards as well as forwards in the code to find the root cause of the problem.

Live Recorder's core recording technology is language independent and designed for Linux-based applications.

Replay

Reverse debugging

Use our interactive reversible debugger UndoDB to replay your recordings and discover what your software really did.

Based on GDB, UndoDB supports source-level debugging for applications written in any language supported by GDB, including C/C++, Rust and Ada.

UndoDB delivers the full power of a modern debugger with variable and memory inspection, scripting, conditional breakpoints and watchpoints, all available in forwards and reverse directions.

Key facts

The technology behind Live Recorder

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.

Accelerate software defect resolution by eliminating the guesswork

Record and replay program execution and quickly diagnose 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. This product forms the core of our two main solutions.