A New Paradigm for Cloud-Native Debugging

Ozcode Live Debugger

Ozcode Cloud Icon

Executive Summary

Production errors have been happening since the dawn of computing and continue to this day. At any time, you can check DownDetector.com to see when services from leading companies go down. Production errors are also very costly to fix, up to 30 times what it costs to fix an error detected during the requirements analysis or design phase of an application. The reason is that it is very complicated to debug production errors. It’s hard to reproduce an error, the root cause is in a different place from where the error is manifested, debug information must be assembled from multiple disparate sources, and more. And cloud computing just makes things worse.

Cloud is simple, agile, and scalable, but hard to debug

The simplicity, agility, and scalability of the cloud have brought it into the mainstream, but cloud deployments introduce several factors that vastly complicate the debugging process. Multitudes of concurrent users make it difficult to reproduce the exact usage scenario that generated an error. Microservices add challenges to trace an exception back through the precise instance of a redundantly deployed service to its source. Serverless code can take part in an error code execution flow, and then disappear. The asynchronous nature of queues makes it difficult to follow the timeline of events…the list goes on. To overcome the complexity of maintaining, monitoring, and debugging cloud applications, several tool categories have entered the market.

Common enterprise tools have their place but fall short in production debugging

The tool stack available to developers in an enterprise usually consists of any or all of Log Analyzers, Application Performance Monitors (APMs), or Error Monitors. While these tools help solve different issues that arise in production systems, none of them are very effective in helping developers determine the root cause of production bugs. Logs can get huge, are dispersed around different modules of the application, and rarely include just the right information a developer needs when something unexpected happens (like a bug/error/exception). APMs and error monitors can aggregate a variety of performance metrics, and even alert you to anomalies in application behavior, but they cannot provide the code-level debug information needed for effective debugging.

The Ozcode production debugging paradigm

Ozcode offers a new paradigm for production debugging based on the following simple principles:

Autonomous exception capture

Ozcode uses a lightweight agent that is deployed alongside your application. When an exception is thrown, the Ozcode agent automatically records all the data needed to perform a root cause analysis of the error and sends it to the Ozcode Live Debugger dashboard.

Code-level observability:

The error data that the Ozcode agent sends to the dashboard allows the debugging engineer to observe data and elements of the actual running code that threw the exception, including relevant log entries, event timeline, call stack, local variables, function return values and more.

Time-travel debugging:

The Ozcode debugging screen provides a decompilation of the complete code execution flow with radical observability. A debugging engineer can step back in time through each line of code and see all variables, method return values, and property getters at the time they were evaluated in the error execution flow.

By recording the error execution flow with radical observability, Ozcode overcomes the obstacles to debugging that cloud computing has introduced. You no longer need to reproduce an error in order to debug it. Whether execution was through microservices and serverless code or not, you just time-travel through the captured exception with radical observability into the error execution flow to determine the root cause of the error and enable a complete and final fix.


Ozcode Live Debugger

Autonomous exception capture
Don’t chase after exceptions. They automatically appear in your dashboard.

Radical observability
Get insights into your code down to the deepest levels.

Time-travel fidelity
View the true state of your code anywhere in the execution flow of an error.

Ozcode Production Debugger - GET A DEMO

Live Debugger

Bridge the gap between finding errors in production and pinpointing their root cause in code

Thanks for downloading the OzCode trial!

You’re well on your way to making C# even sharper.

If your download doesn’t start automatically , please use this direct link.

If you’d like to install OzCode but don’t have
administrative privileges on your machine, please contact us.

Get Started for FREE!

Ozcode Logo

This website uses cookies to ensure you get the best experience on our website.